def test_node_output(self):
self.assertEqual(
4,
node_struct(ParseIntNode(), ['4'], ['in']).resolve_output('out'))
self.assertEqual(
-2,
node_struct(ParseIntNode(), ['-2'], ['in']).resolve_output('out'))
def test_node_output(self):
self.assertEqual(
4,
node_struct(ParseFloatNode(), ['4'], ['in']).resolve_output('out'))
self.assertEqual(
3.1415,
node_struct(ParseFloatNode(), ['3.1415'],
['in']).resolve_output('out'))
def test_node_output(self):
self.assertEqual(
5,
node_struct(PassThroughNode(), [5], ['in']).resolve_output('out'))
self.assertEqual(
'test string',
node_struct(PassThroughNode(), ['test string'],
['in']).resolve_output('out'))
def test_node_output(self):
self.assertEqual(
[1, 2, 3],
node_struct(ArrayNode(3), [1, 2, 3],
['in_0', 'in_1', 'in_2']).resolve_output('merged'))
self.assertEqual(
[1, 2, 3, 5, 8],
node_struct(ArrayNode(3), [[1, 2, 3], 5, 8],
['in_0', 'in_1', 'in_2']).resolve_output('merged'))
self.assertEqual(
[1, 2, 3, 4],
node_struct(ArrayNode(2), [[1, 2], [3, 4]],
['in_0', 'in_1']).resolve_output('merged'))
def test_node_output(self):
self.assertEqual(
'first',
node_struct(IndexNode(), [['first', 'second', 'third'], 0],
['data', 'index']).resolve_output('value'))
self.assertEqual(
'second',
node_struct(IndexNode(), [['first', 'second', 'third'], 1],
['data', 'index']).resolve_output('value'))
self.assertEqual(
'third',
node_struct(IndexNode(), [['first', 'second', 'third'], 2],
['data', 'index']).resolve_output('value'))
def test_node_output(self):
self.assertEqual(
1,
node_struct(DummyNode(), [1, 2],
['in', 'extra']).resolve_output('out'))
self.assertEqual(
2,
node_struct(DummyNode(), [2, 1],
['in', 'extra']).resolve_output('out'))
self.assertEqual(
'this one outputted',
node_struct(DummyNode(), ['this one outputted', 'this one not'],
['in', 'extra']).resolve_output('out'))
def test_node_output(self):
self.assertEqual(
0,
node_struct(IndexOfNode(), [['first', 'second', 'third'], 'first'],
['array', 'search']).resolve_output('index'))
self.assertEqual(
1,
node_struct(IndexOfNode(),
[['first', 'second', 'third'], 'second'],
['array', 'search']).resolve_output('index'))
self.assertEqual(
2,
node_struct(IndexOfNode(), [['first', 'second', 'third'], 'third'],
['array', 'search']).resolve_output('index'))
def test_node_output(self):
self.assertEqual(
{'test': 'true'},
node_struct(DictionaryNode(1), ['test', 'true'],
['key_0', 'value_0']).resolve_output('object'))
self.assertEqual(
{
'a': 1,
'b': 2,
'z': 26
},
node_struct(
DictionaryNode(3), ['a', 'b', 'z', 1, 2, 26],
['key_0', 'key_1', 'key_2', 'value_0', 'value_1', 'value_2'
]).resolve_output('object'))
def test_multiplex_node(self):
self.assertEqual(
'first',
node_struct(
MultiplexNode(3), [0, 'first', 'second', 'third'],
['number', 'in_0', 'in_1', 'in_2']).resolve_output('value'))
self.assertEqual(
'second',
node_struct(
MultiplexNode(3), [1, 'first', 'second', 'third'],
['number', 'in_0', 'in_1', 'in_2']).resolve_output('value'))
self.assertEqual(
'third',
node_struct(
MultiplexNode(3), [2, 'first', 'second', 'third'],
['number', 'in_0', 'in_1', 'in_2']).resolve_output('value'))
def test_node_output(self):
self.assertEqual([1, 2],
node_struct(SliceNode(), [[0, 1, 2, 3, 4], 1, 3],
['array', 'slice_start', 'slice_end'
]).resolve_output('array'))
self.assertEqual(
[2, 3, 4],
node_struct(SliceNode(), [[0, 1, 2, 3, 4], 2],
['array', 'slice_start']).resolve_output('array'))
self.assertEqual(
[0, 1, 2, 3],
node_struct(SliceNode(), [[0, 1, 2, 3, 4], 4],
['array', 'slice_end']).resolve_output('array'))
self.assertEqual(
[0, 2, 4],
node_struct(SliceNode(), [[0, 1, 2, 3, 4], 2],
['array', 'slice_step']).resolve_output('array'))
def test_node_output(self):
self.assertEqual(
'dict',
node_struct(TypeNode(), [{}], ['in']).resolve_output('out'))
self.assertEqual(
'array',
node_struct(TypeNode(), [[]], ['in']).resolve_output('out'))
self.assertEqual(
'int',
node_struct(TypeNode(), [4], ['in']).resolve_output('out'))
self.assertEqual(
'float',
node_struct(TypeNode(), [2.7181], ['in']).resolve_output('out'))
self.assertEqual(
'string',
node_struct(TypeNode(), ['hello world'],
['in']).resolve_output('out'))
def test_node_output(self):
self.assertEqual(
1,
node_struct(IfNode(), [True, 1, 2],
['condition', 'if', 'else']).resolve_output('value'))
self.assertEqual(
2,
node_struct(IfNode(), [False, 1, 2],
['condition', 'if', 'else']).resolve_output('value'))
self.assertEqual(
'if_out',
node_struct(IfNode(), [True, 'if_out', 'else_out'],
['condition', 'if', 'else']).resolve_output('value'))
self.assertEqual(
'else_out',
node_struct(IfNode(), [False, 'if_out', 'else_out'],
['condition', 'if', 'else']).resolve_output('value'))
def test_node_output(self):
self.assertEqual(
'first',
node_struct(SwitchNode(2), [1, 'none', 1, 'first', 2, 'second'], [
'value', 'default', 'test_0', 'return_0', 'test_1', 'return_1'
]).resolve_output('selected'))
self.assertEqual(
'first',
node_struct(SwitchNode(2), [1, 'none', 1, 'first', 2, 'second'], [
'value', 'default', 'test_0', 'return_0', 'test_1', 'return_1'
]).resolve_output('selected'))
self.assertEqual(
'second',
node_struct(SwitchNode(2), [2, 'none', 1, 'first', 2, 'second'], [
'value', 'default', 'test_0', 'return_0', 'test_1', 'return_1'
]).resolve_output('selected'))
self.assertEqual(
'none',
node_struct(SwitchNode(2), [3, 'none', 1, 'first', 2, 'second'], [
'value', 'default', 'test_0', 'return_0', 'test_1', 'return_1'
]).resolve_output('selected'))
def test_node_output(self):
self.assertEqual(
'no iter',
node_struct(LoopNode(), [False, 'no iter'],
['iter', 'value']).resolve_output('value'))
loop_node = LoopNode()
inc_node = IncrementNode()
ne_node = NotEqualsNode()
BaseNode.connect(inc_node, loop_node, 'value', 'value')
BaseNode.connect(inc_node, ne_node, 'increment', 'arg1')
BaseNode.connect(DataSourceNode(5), ne_node, 'data', 'arg2')
BaseNode.connect(ne_node, loop_node, 'result', 'iter')
self.assertEqual(5, loop_node.resolve_output('value'))
def test_node_output(self):
self.assertEqual(0, VariableNode().resolve_output('value'))
self.assertEqual(4, VariableNode(4).resolve_output('value'))
self.assertEqual(
4,
node_struct(VariableNode(), [4],
['value']).resolve_output('update'))
var_node = VariableNode(1)
multiply_node = MultiplyNode()
BaseNode.connect(multiply_node, var_node, 'result', 'value')
BaseNode.connect(var_node, multiply_node, 'value', 'arg1')
BaseNode.connect(DataSourceNode(2), multiply_node, 'data', 'arg2')
self.assertEqual(2, var_node.resolve_output('update'))
self.assertEqual(4, var_node.resolve_output('update'))
self.assertEqual(8, var_node.resolve_output('update'))
def test_node_output(self):
self.assertAlmostEqual(math.pi / 6., node_struct(ArctanNode(), [0.5 / (math.sqrt(3) / 2.)], ['in']).resolve_output('out'))
self.assertAlmostEqual(math.pi / 4., node_struct(ArctanNode(), [1.], ['in']).resolve_output('out'))
def test_node_output(self):
self.assertAlmostEqual(0.5 / (math.sqrt(3) / 2.), node_struct(TanNode(), [math.pi / 6.], ['in']).resolve_output('out'))
self.assertAlmostEqual(1., node_struct(TanNode(), [math.pi / 4.], ['in']).resolve_output('out'))
def test_node_output(self):
self.assertAlmostEqual(math.pi / 6., node_struct(ArccosNode(), [math.sqrt(3) / 2.], ['in']).resolve_output('out'))
self.assertAlmostEqual(math.pi / 4., node_struct(ArccosNode(), [math.sqrt(2) / 2.], ['in']).resolve_output('out'))
