Ichthyostega
bcdcb36615
...to create an ''access path for diagnostics'' and further evaluations while ''bypassing the VTable.'' It is a well-known downside of specifically typed, highly optimisable template-based code to create a dangerous leverage for generating spurious, mostly identical virtual function instances added for secondary concerns. Thus it is a consequence of this design choice, either to forego some diagnostic and analytical possibilities, or to exploit ''other means'' for retrieving internal data, which is needed for tangential purposes only. The solution pursued hereby exploits similar layout of various ''weaving pattern'' template instances to create an ''access backdoor'' for use cases beyond the primary performance-critical path.
479 lines
24 KiB
C++
479 lines
24 KiB
C++
/*
|
||
NodeBase(Test) - unit test to cover the render node base elements
|
||
|
||
Copyright (C)
|
||
2009, Hermann Vosseler <Ichthyostega@web.de>
|
||
|
||
**Lumiera** is free software; you can redistribute it and/or modify it
|
||
under the terms of the GNU General Public License as published by the
|
||
Free Software Foundation; either version 2 of the License, or (at your
|
||
option) any later version. See the file COPYING for further details.
|
||
|
||
* *****************************************************************/
|
||
|
||
/** @file node-base-test.cpp
|
||
** Unit test \ref NodeBase_test covers elementary components of render nodes.
|
||
*/
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/iter-zip.hpp"
|
||
#include "lib/meta/function.hpp"
|
||
#include "steam/engine/proc-node.hpp"
|
||
#include "steam/engine/turnout.hpp"
|
||
#include "steam/engine/turnout-system.hpp"
|
||
#include "steam/engine/feed-manifold.hpp"
|
||
#include "steam/engine/diagnostic-buffer-provider.hpp"
|
||
#include "steam/engine/buffhandle-attach.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
//#include "lib/format-cout.hpp"
|
||
#include "lib/test/diagnostic-output.hpp"/////////////////////TODO
|
||
#include "lib/format-util.hpp"///////////////////////////////TODO
|
||
#include "lib/util.hpp"
|
||
|
||
|
||
//using std::string;
|
||
using std::tuple;
|
||
using std::array;
|
||
using util::isSameAdr;
|
||
using lib::test::showType;
|
||
using lib::izip;
|
||
|
||
|
||
namespace steam {
|
||
namespace engine{
|
||
namespace test {
|
||
|
||
|
||
namespace { // Test fixture
|
||
/**
|
||
*/
|
||
}
|
||
|
||
|
||
/***************************************************************//**
|
||
* @test basic render node properties and behaviour.
|
||
*/
|
||
class NodeBase_test : public Test
|
||
{
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
verify_TurnoutSystem();
|
||
verify_FeedManifold();
|
||
verify_FeedPrototype();
|
||
UNIMPLEMENTED ("build a simple render node and then activate it");
|
||
}
|
||
|
||
/** @test the TurnoutSystem as transient coordinator for node invocation
|
||
*/
|
||
void
|
||
verify_TurnoutSystem()
|
||
{
|
||
Time nomTime{rani(10'000),0}; // drive test with a random »nominal Time« <10s with ms granularity
|
||
TurnoutSystem invoker{nomTime}; // a time spec is mandatory, all further parameters are optional
|
||
////////////////////////////////OOO unfinished - demonstrate simple accesses to the TurnoutSystem
|
||
}
|
||
|
||
|
||
/** @test the FeedManifold as adapter between Engine and processing library
|
||
* - bind local λ with various admissible signatures
|
||
* - construct specifically tailored FeedManifold types
|
||
* - use the DiagnosticBufferProvider for test buffers
|
||
* - create FeedManifold instance, passing the λ and additional parameters
|
||
* - connect BuffHandle for these buffers into the FeedManifold instance
|
||
* - trigger invocation of the function
|
||
* - look into the buffers and verify effect
|
||
* @remark within each Render Node, a FeedManifold is used as junction
|
||
* to tap into processing functionality provided by external libraries.
|
||
* Those will be adapted by a Plug-in, to be loaded by the Lumiera core
|
||
* application. The _signature of a functor_ linked to the FeedManifold
|
||
* is used as kind of a _low-level-specification_ how to invoke external
|
||
* processing functions. Obviously this must be complemented by a more
|
||
* high-level descriptor, which is interpreted by the Builder to connect
|
||
* a suitable structure of Render Nodes.
|
||
* @see feed-manifold.h
|
||
* @see NodeLinkage_test
|
||
*/
|
||
void
|
||
verify_FeedManifold()
|
||
{
|
||
// Prepare setup to build a suitable FeedManifold...
|
||
long r1 = rani(100);
|
||
using Buffer = long;
|
||
|
||
|
||
//______________________________________________________________
|
||
// Example-1: a FeedManifold to adapt a simple generator function
|
||
auto fun_singleOut = [&](Buffer* buff) { *buff = r1; };
|
||
using M1 = FeedManifold<decltype(fun_singleOut)>;
|
||
CHECK (not M1::hasInput());
|
||
CHECK (not M1::hasParam());
|
||
CHECK (0 == M1::FAN_P);
|
||
CHECK (0 == M1::FAN_I);
|
||
CHECK (1 == M1::FAN_O);
|
||
// instantiate...
|
||
M1 m1{fun_singleOut};
|
||
CHECK (1 == m1.outBuff.array().size());
|
||
CHECK (nullptr == m1.outArgs );
|
||
// CHECK (m1.inArgs ); // does not compile because storage field is not provided
|
||
// CHECK (m1.param );
|
||
|
||
BufferProvider& provider = DiagnosticBufferProvider::build();
|
||
BuffHandle buff = provider.lockBufferFor<Buffer> (-55);
|
||
CHECK (buff.isValid());
|
||
CHECK (buff.accessAs<long>() == -55);
|
||
|
||
m1.outBuff.createAt (0, buff); // plant a copy of the BuffHandle into the output slot
|
||
CHECK (m1.outBuff[0].isValid());
|
||
CHECK (m1.outBuff[0].accessAs<long>() == -55);
|
||
|
||
m1.connect(); // instruct the manifold to connect buffers to arguments
|
||
CHECK (isSameAdr (m1.outArgs, *buff));
|
||
CHECK (*m1.outArgs == -55);
|
||
|
||
m1.invoke(); // invoke the adapted processing function (fun_singleOut)
|
||
CHECK (buff.accessAs<long>() == r1); // result: the random number r1 was written into the buffer.
|
||
|
||
|
||
//_____________________________________________________________
|
||
// Example-2: adapt a function to process input -> output buffer
|
||
auto fun_singleInOut = [](Buffer* in, Buffer* out) { *out = *in + 1; };
|
||
using M2 = FeedManifold<decltype(fun_singleInOut)>;
|
||
CHECK ( M2::hasInput());
|
||
CHECK (not M2::hasParam());
|
||
CHECK (1 == M2::FAN_I);
|
||
CHECK (1 == M2::FAN_O);
|
||
// instantiate...
|
||
M2 m2{fun_singleInOut};
|
||
CHECK (1 == m2.inBuff.array().size());
|
||
CHECK (1 == m2.outBuff.array().size());
|
||
CHECK (nullptr == m2.inArgs );
|
||
CHECK (nullptr == m2.outArgs );
|
||
|
||
// use the result of the preceding Example-1 as input
|
||
// and get a new buffer to capture the output
|
||
BuffHandle buffOut = provider.lockBufferFor<Buffer> (-99);
|
||
CHECK (buff.accessAs<long>() == r1);
|
||
CHECK (buffOut.accessAs<long>() == -55); ///////////////////////////////////////OOO should be -99 --> aliasing of buffer meta records due to bug with hash generation
|
||
|
||
// configure the Manifold-2 with this input and output buffer
|
||
m2.inBuff.createAt (0, buff);
|
||
m2.outBuff.createAt(0, buffOut);
|
||
CHECK (m2.inBuff[0].isValid());
|
||
CHECK (m2.inBuff[0].accessAs<long>() == r1 );
|
||
CHECK (m2.outBuff[0].isValid());
|
||
CHECK (m2.outBuff[0].accessAs<long>() == -55); ////////////////////////////////OOO should be -99
|
||
|
||
// connect arguments to buffers
|
||
m2.connect();
|
||
CHECK (isSameAdr (m2.inArgs, *buff));
|
||
CHECK (isSameAdr (m2.outArgs, *buffOut));
|
||
CHECK (*m2.outArgs == -55); ////////////////////////////////OOO should be -99
|
||
|
||
m2.invoke();
|
||
CHECK (buffOut.accessAs<long>() == r1+1);
|
||
|
||
|
||
//______________________________________
|
||
// Example-3: accept complex buffer setup
|
||
using Sequence = array<Buffer,3>;
|
||
using Channels = array<Buffer*,3>;
|
||
using Compound = tuple<Sequence*, Buffer*>;
|
||
auto fun_complexInOut = [](Channels in, Compound out)
|
||
{
|
||
auto [seq,extra] = out;
|
||
for (auto [i,b] : izip(in))
|
||
{
|
||
(*seq)[i] = *b + 1;
|
||
*extra += *b;
|
||
}
|
||
};
|
||
using M3 = FeedManifold<decltype(fun_complexInOut)>;
|
||
CHECK ( M3::hasInput());
|
||
CHECK (not M3::hasParam());
|
||
CHECK (3 == M3::FAN_I);
|
||
CHECK (2 == M3::FAN_O);
|
||
CHECK (showType<M3::ArgI>() == "array<long*, 3ul>"_expect);
|
||
CHECK (showType<M3::ArgO>() == "tuple<array<long, 3ul>*, long*>"_expect);
|
||
// instantiate...
|
||
M3 m3{fun_complexInOut};
|
||
CHECK (3 == m3.inBuff.array().size());
|
||
CHECK (2 == m3.outBuff.array().size());
|
||
|
||
// use existing buffers and one additional buffer for input
|
||
BuffHandle buffI0 = buff;
|
||
BuffHandle buffI1 = buffOut;
|
||
BuffHandle buffI2 = provider.lockBufferFor<Buffer> (-22);
|
||
CHECK (buffI0.accessAs<long>() == r1 ); // (result from Example-1)
|
||
CHECK (buffI1.accessAs<long>() == r1+1); // (result from Example-2)
|
||
CHECK (buffI2.accessAs<long>() == -55 ); ///////////////////////////////////////OOO should be -22
|
||
// prepare a compound buffer and an extra buffer for output...
|
||
BuffHandle buffO0 = provider.lockBufferFor<Sequence> (Sequence{-111,-222,-333});
|
||
BuffHandle buffO1 = provider.lockBufferFor<Buffer> (-33);
|
||
CHECK ((buffO0.accessAs<Sequence>() == Sequence{-111,-222,-333}));
|
||
CHECK (buffO1.accessAs<long>() == -55 ); ///////////////////////////////////////OOO should be -33
|
||
|
||
// configure the Manifold-3 with these input and output buffers
|
||
m3.inBuff.createAt (0, buffI0);
|
||
m3.inBuff.createAt (1, buffI1);
|
||
m3.inBuff.createAt (2, buffI2);
|
||
m3.outBuff.createAt(0, buffO0);
|
||
m3.outBuff.createAt(1, buffO1);
|
||
m3.connect();
|
||
// Verify data exposed prior to invocation....
|
||
auto& [ia0,ia1,ia2] = m3.inArgs;
|
||
auto& [oa0,oa1] = m3.outArgs;
|
||
auto& [o00,o01,o02] = *oa0;
|
||
CHECK (*ia0 == r1 );
|
||
CHECK (*ia1 == r1+1);
|
||
CHECK (*ia2 == -55 ); /////////////////////////////////////////////////////OOO should be -22
|
||
CHECK ( o00 == -111);
|
||
CHECK ( o01 == -222);
|
||
CHECK ( o02 == -333);
|
||
CHECK (*oa1 == -55 ); /////////////////////////////////////////////////////OOO should be -33
|
||
|
||
m3.invoke();
|
||
CHECK (*ia0 == r1 ); // Input buffers unchanged
|
||
CHECK (*ia1 == r1+1);
|
||
CHECK (*ia2 == -55 ); /////////////////////////////////////////////////////OOO should be -22
|
||
CHECK ( o00 == *ia0+1); // Output buffers as processed by the function
|
||
CHECK ( o01 == *ia1+1);
|
||
CHECK ( o02 == *ia2+1);
|
||
CHECK (*oa1 == -55 + *ia0+*ia1+*ia2); ///////////////////////////////////////////OOO should be -33
|
||
|
||
|
||
//_________________________________
|
||
// Example-4: pass a parameter tuple
|
||
using Params = tuple<short,long>;
|
||
// Note: demonstrates mix of complex params, an array for input, but just a simple output buffer
|
||
auto fun_ParamInOut = [](Params param, Channels in, Buffer* out)
|
||
{
|
||
auto [s,l] = param;
|
||
*out = 0;
|
||
for (Buffer* b : in)
|
||
*out += (s+l) * (*b);
|
||
};
|
||
using M4 = FeedManifold<decltype(fun_ParamInOut)>;
|
||
CHECK (M4::hasInput());
|
||
CHECK (M4::hasParam());
|
||
CHECK (2 == M4::FAN_P);
|
||
CHECK (3 == M4::FAN_I);
|
||
CHECK (1 == M4::FAN_O);
|
||
CHECK (showType<M4::ArgI>() == "array<long*, 3ul>"_expect);
|
||
CHECK (showType<M4::ArgO>() == "long *"_expect);
|
||
CHECK (showType<M4::Param>() == "tuple<short, long>"_expect);
|
||
|
||
// Note: instantiate passing param values as extra arguments
|
||
short r2 = 1+rani(10);
|
||
long r3 = rani(1000);
|
||
M4 m4{Params{r2,r3}, fun_ParamInOut}; // parameters directly given by-value
|
||
auto& [p0,p1] = m4.param;
|
||
CHECK (p0 == r2); // parameter values exposed through manifold
|
||
CHECK (p1 == r3);
|
||
|
||
// wire-in existing buffers for this example
|
||
m4.inBuff.createAt (0, buffI0);
|
||
m4.inBuff.createAt (1, buffI1);
|
||
m4.inBuff.createAt (2, buffI2);
|
||
m4.outBuff.createAt(0, buffO1);
|
||
CHECK (*ia0 == r1 ); // existing values in the buffers....
|
||
CHECK (*ia1 == r1+1);
|
||
CHECK (*ia2 == -55 ); /////////////////////////////////////////////////////OOO should be -22
|
||
CHECK (*oa1 == -55 + *ia0+*ia1+*ia2); ///////////////////////////////////////////OOO should be -33
|
||
|
||
m4.connect();
|
||
m4.invoke(); // processing combines input buffers with parameters
|
||
CHECK (*oa1 == (r2+r3) * (r1 + r1+1 -55)); /////////////////////////////////////OOO should be -22
|
||
|
||
|
||
//______________________________________
|
||
// Example-5: simple parameter and output
|
||
auto fun_singleParamOut = [](short param, Buffer* buff) { *buff = param-1; };
|
||
using M5 = FeedManifold<decltype(fun_singleParamOut)>;
|
||
CHECK (not M5::hasInput());
|
||
CHECK ( M5::hasParam());
|
||
CHECK (1 == M5::FAN_P);
|
||
CHECK (0 == M5::FAN_I);
|
||
CHECK (1 == M5::FAN_O);
|
||
CHECK (showType<M5::ArgI>() == "tuple<>"_expect);
|
||
CHECK (showType<M5::ArgO>() == "long *"_expect);
|
||
CHECK (showType<M5::Param>() == "short"_expect);
|
||
|
||
// instantiate, directly passing param value
|
||
M5 m5{r2, fun_singleParamOut};
|
||
// wire with one output buffer
|
||
m5.outBuff.createAt(0, buffO1);
|
||
m5.connect();
|
||
CHECK (m5.param == r2); // the parameter value passed to the ctor
|
||
// CHECK (m5.inArgs ); // does not compile because storage field is not provided
|
||
CHECK (*m5.outArgs == *oa1); // still previous value sitting in the buffer...
|
||
|
||
m5.invoke();
|
||
CHECK (*oa1 == r2 - 1); // processing has placed result based on param into output buffer
|
||
|
||
// done with these buffers
|
||
buffI0.release();
|
||
buffI1.release();
|
||
buffI2.release();
|
||
buffO0.release();
|
||
buffO1.release();
|
||
}
|
||
|
||
|
||
|
||
/** @test Setup of a FeeManifold to attach parameter-functors
|
||
*/
|
||
void
|
||
verify_FeedPrototype()
|
||
{
|
||
// Prepare setup to build a suitable FeedManifold...
|
||
using Buffer = long;
|
||
BufferProvider& provider = DiagnosticBufferProvider::build();
|
||
BuffHandle buff = provider.lockBufferFor<Buffer> (-55);
|
||
|
||
|
||
//_______________________________________
|
||
// Case-1: Prototype without param-functor
|
||
auto fun_singleParamOut = [](short param, Buffer* buff) { *buff = param-1; };
|
||
using M1 = FeedManifold<decltype(fun_singleParamOut)>;
|
||
using P1 = M1::Prototype;
|
||
CHECK ( P1::hasParam()); // checks that the processing-function accepts a parameter
|
||
CHECK (not P1::hasParamFun()); // while this prototype has no active param-functor
|
||
CHECK (not P1::canActivate());
|
||
|
||
P1 p1{move (fun_singleParamOut)}; // create the instance of the prototype, moving the functor in
|
||
CHECK (sizeof(p1) <= sizeof(void*));
|
||
TurnoutSystem turSys{Time::NEVER}; // Each Node invocation uses a TurnoutSystem instance....
|
||
|
||
M1 m1 = p1.buildFeed(turSys); //... and also will create a new FeedManifold from the prototype
|
||
CHECK (m1.param == short{}); // In this case here, the param value is default constructed.
|
||
m1.outBuff.createAt(0, buff); // Perform the usual steps for an invocation....
|
||
CHECK (buff.accessAs<long>() == -55);
|
||
m1.connect();
|
||
CHECK (*m1.outArgs == -55);
|
||
|
||
m1.invoke();
|
||
CHECK (*m1.outArgs == 0 - 1); // fun_singleParamOut() -> param - 1 and param ≡ 0
|
||
CHECK (buff.accessAs<long>() == 0 - 1);
|
||
long& calcResult = buff.accessAs<long>(); // for convenience use a reference into the result buffer
|
||
|
||
|
||
|
||
//_____________________________________________
|
||
// Case-2: Reconfigure to attach a param-functor
|
||
long rr{11}; // ▽▽▽▽ Note: side-effect
|
||
auto fun_paramSimple = [&](TurnoutSystem&){ return rr += 1+rani(100); };
|
||
using P1x = P1::Adapted<decltype(fun_paramSimple)>;
|
||
CHECK ( P1x::hasParam());
|
||
CHECK ( P1x::hasParamFun());
|
||
CHECK (not P1x::canActivate());
|
||
|
||
P1x p1x = p1.moveAdapted (move(fun_paramSimple));
|
||
M1 m1x = p1x.buildFeed(turSys); // ◁————————— param-functor invoked here
|
||
CHECK (rr == m1x.param); // ...as indicated by the side-effect
|
||
short r1 = m1x.param;
|
||
|
||
// the rest works as always with FeedManifold (which as such is agnostic of the param-functor!)
|
||
m1x.outBuff.createAt(0, buff);
|
||
m1x.connect();
|
||
m1x.invoke(); // Invoke the processing functor
|
||
CHECK (calcResult == r1 - 1); // ...which computes fun_singleParamOut() -> param-1
|
||
|
||
// but let's play with the various instances...
|
||
m1.invoke(); // the previous FeedManifold is sill valid and connected
|
||
CHECK (calcResult == 0 - 1); // and uses its baked in parameter value (0)
|
||
m1x.invoke();
|
||
CHECK (calcResult == r1 - 1); // as does m1x, without invoking the param-functor
|
||
|
||
// create yet another instance from the prototype...
|
||
M1 m1y = p1x.buildFeed(turSys); // ◁————————— param-functor invoked here
|
||
CHECK (rr == m1y.param);
|
||
CHECK (r1 < m1y.param); // ...note again the side-effect
|
||
m1y.outBuff.createAt(0, buff);
|
||
m1y.connect();
|
||
m1y.invoke(); // ...and so this third FeedManifold instance...
|
||
CHECK (calcResult == rr - 1); // uses yet another baked-in param value;
|
||
m1x.invoke(); // recall that each Node invocation creates a new
|
||
CHECK (calcResult == r1 - 1); // FeedManifold on the stack, since invocations are
|
||
m1.invoke(); // performed concurrently, each with its own set of
|
||
CHECK (calcResult == 0 - 1); // buffers and parameters.
|
||
|
||
|
||
|
||
//_______________________________
|
||
// Case-3: Integrate std::function
|
||
using ParamSig = short(TurnoutSystem&);
|
||
using ParamFunction = std::function<ParamSig>;
|
||
// a Prototype to hold such a function...
|
||
using P1F = P1::Adapted<ParamFunction>;
|
||
CHECK ( P1F::hasParam());
|
||
CHECK ( P1F::hasParamFun());
|
||
CHECK ( P1F::canActivate());
|
||
|
||
P1F p1f = p1x.clone() // if (and only if) the embedded functors allow clone-copy
|
||
.moveAdapted<ParamFunction>(); // then we can fork-off and then adapt a cloned prototype
|
||
|
||
// Need to distinguish between static capability and runtime state...
|
||
CHECK (not p1 .canActivate()); // Case-1 had no param functor installed...
|
||
CHECK (not p1 .isActivated()); // and thus also can not invoke such a functor at runtime
|
||
CHECK (not p1x.canActivate()); // Case-2 has a fixed param-λ, which can not be activated/deactivated
|
||
CHECK ( p1x.isActivated()); // yet at runtime this functor is always active and callable
|
||
CHECK ( p1f.canActivate()); // Case-3 was defined to hold a std::function, which thus can be toggled
|
||
CHECK (not p1f.isActivated()); // yet in current runtime configuration, the function is empty
|
||
|
||
// create a FeedManifold instance from this prototype
|
||
M1 m1f1 = p1f.buildFeed(turSys); // no param-functor invoked,
|
||
CHECK (m1f1.param == short{}); // so this FeedManifold will use the default-constructed parameter
|
||
|
||
// but since std::function is assignable, we can activate it...
|
||
CHECK (not p1f.isActivated());
|
||
p1f.assignParamFun ([](TurnoutSystem&){ return 47; });
|
||
CHECK ( p1f.isActivated());
|
||
M1 m1f2 = p1f.buildFeed(turSys); // ◁————————— param-functor invoked here
|
||
CHECK (m1f2.param == 47); // ...surprise: we got number 47...
|
||
p1f.assignParamFun();
|
||
CHECK (not p1f.isActivated()); // can /deactivate/ it again...
|
||
M1 m1f3 = p1f.buildFeed(turSys); // so no param-functor invoked here
|
||
CHECK (m1f3.param == short{});
|
||
|
||
// done with buffer
|
||
buff.release();
|
||
|
||
|
||
|
||
//_____________________________________
|
||
// Addendum: type conversion intricacies
|
||
auto lambdaSimple = [ ](TurnoutSystem&){ return short(47); };
|
||
auto lambdaCapture = [&](TurnoutSystem&){ return short(47); };
|
||
using LambdaSimple = decltype(lambdaSimple);
|
||
using LambdaCapture = decltype(lambdaCapture);
|
||
CHECK ( (std::is_constructible<bool,ParamFunction>::value));
|
||
CHECK ( (std::is_constructible<bool,LambdaSimple >::value));
|
||
CHECK (not (std::is_constructible<bool,LambdaCapture>::value));
|
||
// Surprise! a non-capture-λ turns out to be bool convertible,
|
||
// which however is also true for std::function,
|
||
// yet for quite different reasons: While the latter has a
|
||
// built-in conversion operator to detect /inactive/ state,
|
||
// the simple λ decays to a function pointer, which makes it
|
||
// usable as implementation for plain-C callback functions.
|
||
using FunPtr = short(*)(TurnoutSystem&);
|
||
CHECK (not (std::is_convertible<ParamFunction,FunPtr>::value));
|
||
CHECK ( (std::is_convertible<LambdaSimple ,FunPtr>::value));
|
||
CHECK (not (std::is_convertible<LambdaCapture,FunPtr>::value));
|
||
// ..which allows to distinguish these cases..
|
||
//
|
||
CHECK (true == _ParamFun<P1::ProcFun>::isConfigurable<ParamFunction>::value);
|
||
CHECK (false == _ParamFun<P1::ProcFun>::isConfigurable<LambdaSimple >::value);
|
||
CHECK (false == _ParamFun<P1::ProcFun>::isConfigurable<LambdaCapture>::value);
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (NodeBase_test, "unit node");
|
||
|
||
|
||
|
||
}}} // namespace steam::engine::test
|