Test: pEpTestTree - Rebranding! its now PityTest11 \o/

LIB-11
heck 2 years ago
parent f54750366c
commit d04f53b4a7

3
.gitignore vendored

@ -33,3 +33,6 @@ test_pEpLog_basic
*.db
/test/PityTest11/test/test_pEpTest_basic
/test/PityTest11/test/test_transport
/test/PityTest11/test/test_processdirs

@ -0,0 +1,16 @@
#include "PityModel.hh"
#include "iostream"
using namespace std;
namespace pEp {
namespace PityTest11 {
bool PityModel::log_enabled = true;
PityModel::PityModel(const string& name) : name(name) {}
const std::string& PityModel::getName() const
{
return name;
}
} // namespace Test
} // namespace pEp

@ -7,11 +7,11 @@
#include "../../../src/pEpLog.hh"
namespace pEp {
namespace Test {
class pEpTestModel {
namespace PityTest11 {
class PityModel {
public:
pEpTestModel() = delete;
pEpTestModel(const std::string& name);
PityModel() = delete;
PityModel(const std::string& name);
virtual const std::string& getName() const;
private:

@ -1,8 +1,8 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#ifndef LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HH
#define LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HH
#ifndef PITYTEST_PITYUNIT_HH
#define PITYTEST_PITYUNIT_HH
#include <string>
#include <functional>
@ -12,11 +12,11 @@
// Yes, the mem mgmt is purely static on purpose (so far)
namespace pEp {
namespace Test {
namespace PityTest11 {
template<class T = void>
class pEpTestTree {
class PityUnit {
public:
using NodeFunc = std::function<void(const pEpTestTree&)>;
using NodeFunc = std::function<void(const PityUnit&)>;
enum class ExecutionMode
{
@ -29,9 +29,9 @@ namespace pEp {
};
// Constructors are private
pEpTestTree() = delete;
explicit pEpTestTree(
pEpTestTree* parent,
PityUnit() = delete;
explicit PityUnit(
PityUnit* parent,
const std::string& name,
const NodeFunc test_func = nullptr,
T* model = nullptr,
@ -76,13 +76,13 @@ namespace pEp {
void _waitChildProcesses() const;
// Modify
void _addChildNode(pEpTestTree& node);
void _addChildNode(PityUnit& node);
// Query
bool _isProcessNode() const;
bool _isRootNode() const;
const pEpTestTree& _rootNode() const;
const pEpTestTree& _parentingProcessNode() const;
const PityUnit& _rootNode() const;
const PityUnit& _parentingProcessNode() const;
// Util
std::string _normalizeName(std::string name) const;
@ -94,13 +94,13 @@ namespace pEp {
// Fields
const std::string _name;
const pEpTestTree* _parent; //nullptr if RootUnit
T* _model; //nullptr if inherited
const PityUnit* _parent; //nullptr if RootUnit
T* _model; //nullptr if inherited
const NodeFunc _test_func;
ExecutionMode _exec_mode;
static std::string _global_root_dir;
std::map<const std::string, pEpTestTree&> _children; // map to guarantee uniqueness of sibling-names
std::map<const std::string, PityUnit&> _children; // map to guarantee uniqueness of sibling-names
// internal logging
Adapter::pEpLog::pEpLogger& m4gic_logger_n4me = logger_debug;
@ -108,6 +108,6 @@ namespace pEp {
}; // namespace Test
}; // namespace pEp
#include "pEpTestTree.hxx"
#include "PityUnit.hxx"
#endif // LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HH
#endif // PITYTEST_PITYUNIT_HH

@ -1,8 +1,8 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#ifndef LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HXX
#define LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HXX
#ifndef LIBPEPADAPTER_PEPTEST_PityUnit_HXX
#define LIBPEPADAPTER_PEPTEST_PityUnit_HXX
#include "../../../src/std_utils.hh"
#include "../../framework/utils.hh"
@ -15,22 +15,20 @@
#include <sstream>
using namespace std;
using namespace pEp::Adapter;
using namespace pEp::Utils;
using namespace pEp::Adapter::pEpLog;
namespace pEp {
namespace Test {
namespace PityTest11 {
template<class T>
string pEpTestTree<T>::_global_root_dir = "./peptest";
std::string PityUnit<T>::_global_root_dir = "./peptest";
template<class T>
bool pEpTestTree<T>::debug_log_enabled = false;
bool PityUnit<T>::debug_log_enabled = false;
// PUBLIC CONCSTRUCTORS / FACTORY -----------------------------------------------------------
template<class T>
pEpTestTree<T>::pEpTestTree(
pEpTestTree* const parent,
const string& name,
PityUnit<T>::PityUnit(
PityUnit* const parent,
const std::string& name,
const NodeFunc test_func,
T* model,
ExecutionMode exec_mode) :
@ -44,16 +42,15 @@ namespace pEp {
}
template<class T>
string pEpTestTree<T>::getNodeName() const
std::string PityUnit<T>::getNodeName() const
{
return _name;
}
template<class T>
string pEpTestTree<T>::getNodePath() const
std::string PityUnit<T>::getNodePath() const
{
pEpLogClass("called");
string ret;
std::string ret;
if (!_isRootNode()) {
ret = _parent->getNodePath() + "/" + getNodeName();
@ -69,9 +66,9 @@ namespace pEp {
// When Process as dir. parent - ".../<proc>/name"
// When no process as dir. parent - ".../<proc>/.../name"
template<class T>
std::string pEpTestTree<T>::getNodePathShort() const
std::string PityUnit<T>::getNodePathShort() const
{
string ret;
std::string ret;
if (_isRootNode()) {
ret = getNodeName();
} else {
@ -90,7 +87,7 @@ namespace pEp {
// Inherited (if null see parent recursively)
template<class T>
T* pEpTestTree<T>::getModel() const
T* PityUnit<T>::getModel() const
{
pEpLogClass("called");
T* ret = nullptr;
@ -105,114 +102,100 @@ namespace pEp {
return ret;
}
// RootNodes have their own data_dir
// ProcessNodes have their own data_dir inside their RootNote dir (nameclash prossible)
// All other nodes inherit data_dir from their Root/ProcessNode
// string pEpTestTree::dataDir() const
// {
// pEpLogClass("called");
// string ret;
// if(!_isRootNode()) {
// ret = getRootNodesDir() + _getRootNode().getNodeName() + "/" + _getParentingProcessNode().getNodeName() + "/";
// } else {
// ret = getRootNodesDir() + _getRootNode().getNodeName() + "/";
// }
// return ret;
// }
//
// Every RootNode has its own dir
template<class T>
string pEpTestTree<T>::rootNodeDir() const
std::string PityUnit<T>::rootNodeDir() const
{
return getGlobalRootDir() + _rootNode().getNodeName() + "/";
}
// Every process has its own dir inside its rootNodeDir
// The Root node has its own processDir for future use
// All other nodes inherit processDir from their Root/ProcessNode
template<class T>
string pEpTestTree<T>::processDir() const
std::string PityUnit<T>::processDir() const
{
if (_isRootNode()) {
return rootNodeDir() + "rootnode_data";
return rootNodeDir();
} else {
if (&_parentingProcessNode() == &_rootNode()) {
if (_isProcessNode()) {
return rootNodeDir() + getNodeName() + "/";
} else {
return rootNodeDir() + _parentingProcessNode().getNodeName() + "/";
};
} else{
return _parent->processDir();
}
}
}
template<class T>
void pEpTestTree<T>::setExecutionMode(ExecutionMode mode)
void PityUnit<T>::setExecutionMode(ExecutionMode mode)
{
_exec_mode = mode;
}
// static
template<>
void pEpTestTree<void>::setGlobalRootDir(const string& dir)
void PityUnit<void>::setGlobalRootDir(const std::string& dir)
{
pEpTestTree::_global_root_dir = dir;
PityUnit::_global_root_dir = dir;
}
// static
template<class T>
string pEpTestTree<T>::getGlobalRootDir()
std::string PityUnit<T>::getGlobalRootDir()
{
return pEpTestTree::_global_root_dir + "/";
return PityUnit::_global_root_dir;
}
template<class T>
void pEpTestTree<T>::run() const
void PityUnit<T>::run() const
{
pEpLogClass("called");
// caller is never nullptr if called by another pEpTestTree
// caller is never nullptr if called by another PityUnit
if (_isRootNode()) {
pEpLog::logH1("Starting pEpTestTree from node: " + getNodePathShort());
pEpLog::log(to_string());
logH1("Starting PityUnit from node: " + getNodePathShort());
log(to_string());
}
// Execute in fork and wait here until process ends
if (_exec_mode == ExecutionMode::PROCESS_SEQUENTIAL) { // fork
pEpLog::logH2("[ " + to_string(_exec_mode) + " / " + getNodePathShort() + "]");
_executeInFork(bind(&pEpTestTree::_run, this), true);
logH2("[ " + to_string(_exec_mode) + " / " + getNodePathShort() + " ]");
_executeInFork(std::bind(&PityUnit::_run, this), true);
// Execute in fork and go on, wait for process execution in the end
} else if (_exec_mode == ExecutionMode::PROCESS_PARALLEL) {
pEpLog::logH2("[ " + to_string(_exec_mode) + " / " + getNodePathShort() + "]");
_executeInFork(bind(&pEpTestTree::_run, this), false);
logH2("[ " + to_string(_exec_mode) + " / " + getNodePathShort() + " ]");
_executeInFork(std::bind(&PityUnit::_run, this), false);
// Execute as normal funciton
} else if (_exec_mode == ExecutionMode::FUNCTION) {
pEpLog::logH3("[ " + to_string(_exec_mode) + " / " + getNodePathShort() + "]");
logH3("[ " + to_string(_exec_mode) + " / " + getNodePathShort() + " ]");
_run();
} else if (_exec_mode == ExecutionMode::THREAD_PARALLEL) {
throw invalid_argument(to_string(_exec_mode) + " - not implemented");
throw std::invalid_argument(to_string(_exec_mode) + " - not implemented");
} else if (_exec_mode == ExecutionMode::THREAD_SEQUENTIAL) {
throw invalid_argument(to_string(_exec_mode) + " - not implemented");
throw std::invalid_argument(to_string(_exec_mode) + " - not implemented");
}
_waitChildProcesses();
if(_isRootNode()) {
_waitChildProcesses();
}
}
template<class T>
string pEpTestTree<T>::to_string(bool recursive, int indent) const
std::string PityUnit<T>::to_string(bool recursive, int indent) const
{
string ret;
stringstream builder;
builder << string(indent * 4, ' ');
std::string ret;
std::stringstream builder;
builder << std::string(indent * 4, ' ');
builder << getNodeName();
builder << " [ ";
builder << to_string(_exec_mode) << " - ";
builder << "\"" << processDir() << "\"";
builder << " ]";
builder << endl;
builder << std::endl;
ret = builder.str();
if (recursive) {
indent++;
for (const pair<string, const pEpTestTree&> child : _children) {
for (const std::pair<std::string, const PityUnit&> child : _children) {
ret += child.second.to_string(true, indent);
}
indent--;
@ -221,7 +204,7 @@ namespace pEp {
}
template<class T>
string pEpTestTree<T>::to_string(const ExecutionMode& emode)
std::string PityUnit<T>::to_string(const ExecutionMode& emode)
{
switch (emode) {
case ExecutionMode::FUNCTION:
@ -243,50 +226,50 @@ namespace pEp {
//Well, ok, lets just add some little convenience logging service in here, too
template<class T>
void pEpTestTree<T>::log(const string& msg) const
void PityUnit<T>::log(const std::string& msg) const
{
stringstream builder;
std::stringstream builder;
builder << "[";
builder << std::to_string(getpid());
builder << " - ";
builder << getNodePathShort();
builder << "] - ";
builder << msg;
builder << endl;
cout << builder.str();
builder << std::endl;
std::cout << builder.str();
}
// PRIVATE ---------------------------------------------------------------------------------
template<class T>
void pEpTestTree<T>::_run() const
void PityUnit<T>::_run() const
{
_runSelf();
_runChildren();
}
template<class T>
void pEpTestTree<T>::_runSelf() const
void PityUnit<T>::_runSelf() const
{
if (_test_func != nullptr) {
_test_func(*this);
} else {
pEpLog::log("No function to execute");
log("No function to execute");
}
}
template<class T>
void pEpTestTree<T>::_runChildren() const
void PityUnit<T>::_runChildren() const
{
if (!_children.empty()) {
for (const pair<string, pEpTestTree&> child : _children) {
for (const std::pair<std::string, PityUnit&> child : _children) {
child.second.run();
}
}
}
template<class T>
void pEpTestTree<T>::_executeInFork(function<void(void)> func, bool wait_child) const
void PityUnit<T>::_executeInFork(std::function<void(void)> func, bool wait_child) const
{
pid_t pid;
pid = fork();
@ -294,7 +277,7 @@ namespace pEp {
func();
exit(0);
} else if (pid < pid_t(0)) {
throw runtime_error("Error forking");
throw std::runtime_error("Error forking");
}
if (wait_child) {
_waitChildProcesses();
@ -302,25 +285,25 @@ namespace pEp {
}
template<class T>
void pEpTestTree<T>::_waitChildProcesses() const
void PityUnit<T>::_waitChildProcesses() const
{
int status;
pid_t pid;
while ((pid = wait(&status)) > 0) {
pEpLog::log(
log(
"process[" + std::to_string((int)pid) +
"] terminated with status: " + std::to_string(status));
}
}
template<class T>
void pEpTestTree<T>::_addChildNode(pEpTestTree& node)
void PityUnit<T>::_addChildNode(PityUnit& node)
{
_children.insert(pair<string, pEpTestTree&>(node.getNodeName(), node));
_children.insert(std::pair<std::string, PityUnit&>(node.getNodeName(), node));
}
template<class T>
bool pEpTestTree<T>::_isProcessNode() const
bool PityUnit<T>::_isProcessNode() const
{
bool ret = false;
if (_exec_mode == ExecutionMode::PROCESS_SEQUENTIAL ||
@ -331,7 +314,7 @@ namespace pEp {
}
template<class T>
bool pEpTestTree<T>::_isRootNode() const
bool PityUnit<T>::_isRootNode() const
{
if (_parent == nullptr) {
return true;
@ -341,9 +324,9 @@ namespace pEp {
}
template<class T>
const pEpTestTree<T>& pEpTestTree<T>::_rootNode() const
const PityUnit<T>& PityUnit<T>::_rootNode() const
{
const pEpTestTree* ret = nullptr;
const PityUnit* ret = nullptr;
if (!_isRootNode()) {
ret = &(_parent->_rootNode());
} else {
@ -356,7 +339,7 @@ namespace pEp {
}
template<class T>
const pEpTestTree<T>& pEpTestTree<T>::_parentingProcessNode() const
const PityUnit<T>& PityUnit<T>::_parentingProcessNode() const
{
if (_isRootNode() || _isProcessNode()) {
return *this;
@ -367,7 +350,7 @@ namespace pEp {
// name is alphanumeric only (everything else will be replaced by an underscore)
template<class T>
string pEpTestTree<T>::_normalizeName(string name) const
std::string PityUnit<T>::_normalizeName(std::string name) const
{
replace_if(
name.begin(),
@ -379,24 +362,24 @@ namespace pEp {
}
template<class T>
void pEpTestTree<T>::_data_dir_create()
void PityUnit<T>::_data_dir_create()
{
// Utils::dir_create(dataDir());
pEpLog::log("creating dir:" + getGlobalRootDir());
log("creating dir:" + getGlobalRootDir());
}
template<class T>
void pEpTestTree<T>::_data_dir_delete()
void PityUnit<T>::_data_dir_delete()
{
try {
Utils::path_delete_all(getGlobalRootDir());
} catch (const exception& e) {
pEpLog::log("DistTest: - could not delete data dir: " + getGlobalRootDir());
} catch (const std::exception& e) {
log("DistTest: - could not delete data dir: " + getGlobalRootDir());
}
}
template<class T>
void pEpTestTree<T>::_data_dir_recreate()
void PityUnit<T>::_data_dir_recreate()
{
_data_dir_delete();
_data_dir_create();
@ -404,4 +387,4 @@ namespace pEp {
} // namespace Test
} // namespace pEp
#endif // LIBPEPADAPTER_PEPTEST_PEPTESTTREE_HXX
#endif // LIBPEPADAPTER_PEPTEST_PityUnit_HXX

@ -0,0 +1,65 @@
#include "../src/PityUnit.hh"
#include <iostream>
using namespace std;
using namespace pEp::PityTest11;
void printHomeDir(const PityUnit<>& myself, int sleepmilis, int rep_count)
{
int i = 0;
while (i < rep_count) {
myself.log(myself.getNodeName() + " - " + to_string(i));
sleep_millis(sleepmilis);
i++;
}
}
int main(int argc, char* argv[])
{
{
// DEBUG Logging of pEpTestTree itself
PityUnit<>::debug_log_enabled = false;
// Configure DataRoot for all TestNodes
PityUnit<>::setGlobalRootDir("./basic_data_root");
// The RootNode is the
PityUnit<> root = PityUnit<>{ nullptr, "Test Execution Model" };
// Subprocess 1
PityUnit<> test1 = PityUnit<>{ &root,
"node1",
[](const PityUnit<>& mynode) {
printHomeDir(mynode, 200, 10);
},
nullptr,
pEp::PityTest11::PityUnit<>::ExecutionMode::PROCESS_PARALLEL };
PityUnit<> test1_1 = PityUnit<>{ &test1, "test1.1", [](const PityUnit<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
PityUnit<> test1_2 = PityUnit<>{ &test1, "test1.2", [](const PityUnit<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
// Subprocess 2
PityUnit<> test2 = PityUnit<>{ &root,
"node2",
[](const PityUnit<>& mynode) {
printHomeDir(mynode, 200, 10);
},
nullptr,
pEp::PityTest11::PityUnit<>::ExecutionMode::PROCESS_PARALLEL };
PityUnit<> test2_1 = PityUnit<>{ &test2, "test2.1", [](const PityUnit<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
PityUnit<> test2_2 = PityUnit<>{ &test2, "test2.2", [](const PityUnit<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
test1.run();
}
}

@ -0,0 +1,50 @@
#include "../src/PityUnit.hh"
#include "../../framework/utils.hh"
#include <iostream>
#include <algorithm>
using namespace std;
using namespace pEp::PityTest11;
void printHomeDir(const PityUnit<>& myself)
{
// TESTLOG(string(myself.getFQName() + " - PID: " + to_string(getpid())));
// cout << "[" << to_string(getpid()) << "/" << myself.getFQName() << "] - " << endl;
setenv("HOME", myself.processDir().c_str(), 1);
myself.log("HOME=" + string(getenv("HOME")));
}
int main(int argc, char* argv[])
{
PityUnit<>::debug_log_enabled = false;
PityUnit<>::setGlobalRootDir("./");
PityUnit<> root = PityUnit<>{ nullptr, "rootnode" };
PityUnit<> test1 = PityUnit<>{ &root, "node 1", [](const PityUnit<>& mynode) {
assert(mynode.processDir() == "./rootnode/");
} };
PityUnit<> test1_1 = PityUnit<>{ &test1, "node 1.1", [](const PityUnit<>& mynode) {
assert(mynode.processDir() == "./rootnode/");
} };
PityUnit<> test2 = PityUnit<>{ &root, "node 2", [](const PityUnit<>& mynode) {
assert(mynode.processDir() == "./rootnode/");
} };
PityUnit<> test2_1 = PityUnit<>{ &test2,
"node 2.1",
[](const PityUnit<>& mynode) {
assert(mynode.processDir() == "./rootnode/");
},
nullptr,
pEp::PityTest11::PityUnit<>::ExecutionMode::PROCESS_PARALLEL };
PityUnit<> test2_1_1 = PityUnit<>{ &test2_1, "node 2.1.1", [](PityUnit<> mynode) {
assert(mynode.processDir() == "./rootnode/");
} };
root.run();
}

@ -1,16 +0,0 @@
#include "pEpTestModel.hh"
#include "iostream"
using namespace std;
namespace pEp {
namespace Test {
bool pEpTestModel::log_enabled = true;
pEpTestModel::pEpTestModel(const string& name) : name(name) {}
const std::string& pEpTestModel::getName() const
{
return name;
}
} // namespace Test
} // namespace pEp

@ -1,72 +0,0 @@
#include "../src/pEpTestTree.hh"
#include "../../framework/utils.hh"
#include <iostream>
#include <unistd.h>
using namespace std;
using namespace pEp;
using namespace pEp::Test;
void printHomeDir(const pEpTestTree<>& myself, int sleepmilis, int rep_count)
{
// TESTLOGH1("HYA FROM:" + myself.getFQName());
int i = 0;
while (i < rep_count) {
myself.log(myself.getNodeName() + " - " + to_string(i));
// TESTLOG(string(myself.getFQName() + " - PID: " + to_string(getpid()) + " - " + to_string(i)));
sleep_millis(sleepmilis);
i++;
}
}
int main(int argc, char* argv[])
{
string dummy;
{
// DEBUG Logging of pEpTestTree itself
pEpTestTree<>::debug_log_enabled = false;
// Configure DataRoot for all TestNodes
pEpTestTree<>::setGlobalRootDir("./basic_data_root");
// The RootNode is the
pEpTestTree<> root = pEpTestTree<>{ nullptr, "Test Execution Model"};
// Subprocess 1
pEpTestTree<> test1 = pEpTestTree<>{
&root,
"node1",
[](const pEpTestTree<>& mynode) { printHomeDir(mynode, 200, 10); },
nullptr,
pEp::Test::pEpTestTree<>::ExecutionMode::PROCESS_PARALLEL
};
pEpTestTree<> test1_1 = pEpTestTree<>{ &test1, "test1.1", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
pEpTestTree<> test1_2 = pEpTestTree<>{ &test1, "test1.2", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
// Subprocess 2
pEpTestTree<> test2 = pEpTestTree<>{
&root,
"node2",
[](const pEpTestTree<>& mynode) { printHomeDir(mynode, 200, 10); },
nullptr,
pEp::Test::pEpTestTree<>::ExecutionMode::PROCESS_PARALLEL
};
pEpTestTree<> test2_1 = pEpTestTree<>{ &test2, "test2.1", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
pEpTestTree<> test2_2 = pEpTestTree<>{ &test2, "test2.2", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode, 200, 10);
} };
root.run();
}
}

@ -1,53 +0,0 @@
#include "../src/pEpTestTree.hh"
#include "../../framework/utils.hh"
#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <algorithm>
//#include <regex>
using namespace std;
using namespace pEp;
using namespace pEp::Test;
void printHomeDir(const pEpTestTree<>& myself)
{
// TESTLOG(string(myself.getFQName() + " - PID: " + to_string(getpid())));
// cout << "[" << to_string(getpid()) << "/" << myself.getFQName() << "] - " << endl;
setenv("HOME", myself.processDir().c_str(), 1);
myself.log("HOME=" + string(getenv("HOME")));
}
int main(int argc, char* argv[])
{
pEpTestTree<>::debug_log_enabled = true;
pEpTestTree<>::setGlobalRootDir("./testdata");
pEpTestTree<> root = pEpTestTree<>{ nullptr, "rootnode"};
pEpTestTree<> test1 = pEpTestTree<>{ &root, "node 1", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode);
} };
pEpTestTree<> test1_1 = pEpTestTree<>{ &test1, "node 1.1", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode);
} };
pEpTestTree<> test2 = pEpTestTree<>{ &root, "node 2", [](const pEpTestTree<>& mynode) {
printHomeDir(mynode);
} };
pEpTestTree<> test2_1 = pEpTestTree<>{ &test2,
"node 2.1",
[](const pEpTestTree<>& mynode) { printHomeDir(mynode); },
nullptr,
pEp::Test::pEpTestTree<>::ExecutionMode::PROCESS_PARALLEL };
pEpTestTree<> test2_1_1 = pEpTestTree<>{ &test2_1, "node 2.1.1", [](pEpTestTree<> mynode) {
printHomeDir(mynode);
} };
root.run();
}
Loading…
Cancel
Save