lumiera_/tests/46node.tests

TESTING "Component Test Suite: Render Engine parts" ./test-suite --group=node


TEST "Proc Node basics" NodeBase_test <<END
END


TEST "Proc Node creation" NodeBuilder_test <<END
END


TEST "Proc Node test setup" NodeDevel_test <<END
END


TEST "Proc Node data feeds" NodeFeed_test <<END
END


TEST "Proc Node connectivity" NodeLink_test <<END
END


TEST "Proc Node metadata key" NodeMeta_test <<END
END


PLANNED "Proc Node operation modes" NodeOpera_test <<END
END


PLANNED "Proc Node engine storage setup" NodeStorage_test <<END
END
Dispatcher-Pipeline: prepare test for the new NodeGraphAttachment It turns out that the real (not mocked) implementation of JobTicket creation is already required now for this planned (mock)Dispatcher setup; moreover, this real implementation turns out to be almost identical to the mock implementation written recently -- just nested structure of prerequiste JobTickets need to be changed into a similar structur of ExitNodes -- as an aside: rearrange various tests to be more in-line with the envisioned architecture of playback and engine 2023-06-07 04:03:00 +02:00			`TESTING "Component Test Suite: Render Engine parts" ./test-suite --group=node`



Invocation: complement `NodeBase_test` with simple example While initially intended as introductory test, it meanwhile focuses on intricate technical details on the level of basic building blocks, notably the `FeedManifold` Now I have added a simple end-to-end demonstration example how a Render Node is built from scratch, leaving out all technical details and all convenience front-ends like the `NodeBuilder` — just one dummy port invoked directly. 2025-02-19 01:30:54 +01:00			`TEST "Proc Node basics" NodeBase_test <<END`
Dispatcher-Pipeline: prepare test for the new NodeGraphAttachment It turns out that the real (not mocked) implementation of JobTicket creation is already required now for this planned (mock)Dispatcher setup; moreover, this real implementation turns out to be almost identical to the mock implementation written recently -- just nested structure of prerequiste JobTickets need to be changed into a similar structur of ExitNodes -- as an aside: rearrange various tests to be more in-line with the envisioned architecture of playback and engine 2023-06-07 04:03:00 +02:00			`END`


Invocation: complete demonstration of Node tree with Param Agent (closes #1386) This is a high-level integration test to sum up this development effort * an advanced refactoring was carried out to introduce a flexible and fully-typed binding for the ''processing-functor'' * this entailed a complete rework of the `FeedManifold` to integrate inline storage for a ''parameter tuple'' and input / output ''buffer tuples'' * optional ''parameter functors'' were included into the design at a deep level, closely related to the binding of the processing-functor * the chosen design is thus a compromise between ''everything nodes'' and a ''dedicated parameter-handling'' at invocation level As a proof-of-concept, an scheme to handle extended parameters was devised, using a special »Param Agent Node« and extension storage blocks in stack memory. While not immediately necessary, this design exercise proves the overall design is flexible enough to accommodate future extended needs. 2025-01-05 20:23:21 +01:00			`TEST "Proc Node creation" NodeBuilder_test <<END`
Invocation: establish a concept how to handle parameter data This was an extended digression into architecture planning, which became necessary in order to suitably map out the role for the `TurnoutSystem` — which can now be defined as ''mediator'' to connect and forward control- and parameter data while specific render invocation proceeds through the render node network. 2024-12-05 23:58:22 +01:00			`END`


Invocation: rearrange the Render Node development tests This is an attempt to take aim at the next step, which is to fill in the missing part for an actual node invocation... ''...still fighting to get ahead, due to complexity of involced concerns...'' 2024-12-06 23:43:18 +01:00			`TEST "Proc Node test setup" NodeDevel_test <<END`
Dispatcher-Pipeline: prepare test for the new NodeGraphAttachment It turns out that the real (not mocked) implementation of JobTicket creation is already required now for this planned (mock)Dispatcher setup; moreover, this real implementation turns out to be almost identical to the mock implementation written recently -- just nested structure of prerequiste JobTickets need to be changed into a similar structur of ExitNodes -- as an aside: rearrange various tests to be more in-line with the envisioned architecture of playback and engine 2023-06-07 04:03:00 +02:00			`END`


Invocation: ++ Milestone ++ invoke complex render graph Based on the building blocks developed thus far, it was possible to assemble a typical media processing chain * two source nodes * one of these passes data through a filter * a mixer node on top to combine both chains * time-based automation for processing parameters As actual computation, hash-chaining on blocks of reproducible random data was used, allowing to verify for every data word that expected computations were carried out, in the expected order. 2025-02-19 23:27:52 +01:00			`TEST "Proc Node data feeds" NodeFeed_test <<END`
Invocation: forge a path for integration Facing quite some difficulties here, since there are (at least) two abandoned past efforts towards building a render node network in the code base; the structure and architecture decisions from these previous attempts seem largely valid still, yet on a technical level, the style of construction evolved considerably in the meantime. Moreover, these old fragments of code, written during the early stages of the project, were lacking clear goals and anchor points at places; the situation is quite different now in this respect. Sticking to well proven practice, the rework will be driven by a test setup, and will progress over three steps with increasing levels of integration. 2024-04-22 23:13:55 +02:00			`END`


Invocation: ++ Milestone ++ invoke complex render graph Based on the building blocks developed thus far, it was possible to assemble a typical media processing chain * two source nodes * one of these passes data through a filter * a mixer node on top to combine both chains * time-based automation for processing parameters As actual computation, hash-chaining on blocks of reproducible random data was used, allowing to verify for every data word that expected computations were carried out, in the expected order. 2025-02-19 23:27:52 +01:00			`TEST "Proc Node connectivity" NodeLink_test <<END`
Dispatcher-Pipeline: prepare test for the new NodeGraphAttachment It turns out that the real (not mocked) implementation of JobTicket creation is already required now for this planned (mock)Dispatcher setup; moreover, this real implementation turns out to be almost identical to the mock implementation written recently -- just nested structure of prerequiste JobTickets need to be changed into a similar structur of ExitNodes -- as an aside: rearrange various tests to be more in-line with the envisioned architecture of playback and engine 2023-06-07 04:03:00 +02:00			`END`


Invocation: ++ Milestone ++ invoke complex render graph Based on the building blocks developed thus far, it was possible to assemble a typical media processing chain * two source nodes * one of these passes data through a filter * a mixer node on top to combine both chains * time-based automation for processing parameters As actual computation, hash-chaining on blocks of reproducible random data was used, allowing to verify for every data word that expected computations were carried out, in the expected order. 2025-02-19 23:27:52 +01:00			`TEST "Proc Node metadata key" NodeMeta_test <<END`
Invocation: forge a path for integration Facing quite some difficulties here, since there are (at least) two abandoned past efforts towards building a render node network in the code base; the structure and architecture decisions from these previous attempts seem largely valid still, yet on a technical level, the style of construction evolved considerably in the meantime. Moreover, these old fragments of code, written during the early stages of the project, were lacking clear goals and anchor points at places; the situation is quite different now in this respect. Sticking to well proven practice, the rework will be driven by a test setup, and will progress over three steps with increasing levels of integration. 2024-04-22 23:13:55 +02:00			`END`


Invocation: rearrange the Render Node development tests This is an attempt to take aim at the next step, which is to fill in the missing part for an actual node invocation... ''...still fighting to get ahead, due to complexity of involced concerns...'' 2024-12-06 23:43:18 +01:00			`PLANNED "Proc Node operation modes" NodeOpera_test <<END`
			`END`


			`PLANNED "Proc Node engine storage setup" NodeStorage_test <<END`
Dispatcher-Pipeline: prepare test for the new NodeGraphAttachment It turns out that the real (not mocked) implementation of JobTicket creation is already required now for this planned (mock)Dispatcher setup; moreover, this real implementation turns out to be almost identical to the mock implementation written recently -- just nested structure of prerequiste JobTickets need to be changed into a similar structur of ExitNodes -- as an aside: rearrange various tests to be more in-line with the envisioned architecture of playback and engine 2023-06-07 04:03:00 +02:00			`END`