Exemplo n.º 1
0
def init_struct(init_value):
    equals_node = EqualsNode()
    d1 = DataSourceNode(init_value)
    d2 = DataSourceNode(init_value)
    BaseNode.connect(d1, equals_node, 'data', 'arg1')
    BaseNode.connect(d2, equals_node, 'data', 'arg2')
    return equals_node, d1, d2
Exemplo n.º 2
0
def init_gte_struct(d1_init, d2_init):
    greater_than_node = GreaterThanOrEqualNode()
    d1 = DataSourceNode(d1_init)
    d2 = DataSourceNode(d2_init)
    BaseNode.connect(d1, greater_than_node, 'data', 'arg1')
    BaseNode.connect(d2, greater_than_node, 'data', 'arg2')
    return greater_than_node, d1, d2
Exemplo n.º 3
0
def init_lte_struct(d1_init, d2_init):
    less_than_node = LessThanOrEqualNode()
    d1 = DataSourceNode(d1_init)
    d2 = DataSourceNode(d2_init)
    BaseNode.connect(d1, less_than_node, 'data', 'arg1')
    BaseNode.connect(d2, less_than_node, 'data', 'arg2')
    return less_than_node, d1, d2
Exemplo n.º 4
0
def init_ne_struct(d1_init, d2_init):
    equals_node = NotEqualsNode()
    d1 = DataSourceNode(d1_init)
    d2 = DataSourceNode(d2_init)
    BaseNode.connect(d1, equals_node, 'data', 'arg1')
    BaseNode.connect(d2, equals_node, 'data', 'arg2')
    return equals_node, d1, d2
Exemplo n.º 5
0
 def test_node_output(self):
     ceil_node = CeilNode()
     d_node = DataSourceNode(1.2)
     BaseNode.connect(d_node, ceil_node, 'data', 'value')
     self.assertEqual(ceil_node.resolve_output('result'), 2)
     d_node.data = 1.8
     self.assertEqual(ceil_node.resolve_output('result'), 2)
     d_node.data = -4.4
     self.assertEqual(ceil_node.resolve_output('result'), -4)
Exemplo n.º 6
0
 def test_node_output(self):
     floor_node = FloorNode()
     d_node = DataSourceNode(1.2)
     BaseNode.connect(d_node, floor_node, 'data', 'value')
     self.assertEqual(floor_node.resolve_output('result'), 1)
     d_node.data = 1.8
     self.assertEqual(floor_node.resolve_output('result'), 1)
     d_node.data = -4.4
     self.assertEqual(floor_node.resolve_output('result'), -5)
Exemplo n.º 7
0
 def test_node_output(self):
     abs_node = AbsoluteValueNode()
     d_node = DataSourceNode(6.5)
     BaseNode.connect(d_node, abs_node, 'data', 'in')
     self.assertEqual(abs_node.resolve_output('result'), 6.5)
     d_node.data = -4.2
     self.assertEqual(abs_node.resolve_output('result'), 4.2)
     d_node.data = 0.
     self.assertEqual(abs_node.resolve_output('result'), 0)
Exemplo n.º 8
0
 def test_node_output(self):
     round_node = RoundNode()
     d_node = DataSourceNode(1.2)
     BaseNode.connect(d_node, round_node, 'data', 'value')
     self.assertEqual(round_node.resolve_output('result'), 1)
     d_node.data = 1.8
     self.assertEqual(round_node.resolve_output('result'), 2)
     d_node.data = -4.4
     self.assertEqual(round_node.resolve_output('result'), -4)
     d_node.data = 4.5
     self.assertEqual(round_node.resolve_output('result'), 5)
Exemplo n.º 9
0
 def test_node_output(self):
     find_node = FindNode()
     add_node = AddNode()
     eq_node = EqualsNode()
     BaseNode.connect(DataSourceNode([0, 1, 2, 3, 4, 5, 6]), find_node,
                      'data', 'array')
     BaseNode.connect(find_node, add_node, 'entry', 'arg1')
     BaseNode.connect(DataSourceNode(3), add_node, 'data', 'arg2')
     BaseNode.connect(add_node, eq_node, 'result', 'arg1')
     BaseNode.connect(DataSourceNode(7), eq_node, 'data', 'arg2')
     BaseNode.connect(eq_node, find_node, 'result', 'matches')
     self.assertEqual(4, find_node.resolve_output('match'))
Exemplo n.º 10
0
    def test_node_output(self):
        filter_node = FilterNode()
        BaseNode.connect(DataSourceNode([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
                         filter_node, 'data', 'array')
        mod_node = ModulusNode()
        eq_node = EqualsNode()
        BaseNode.connect(filter_node, mod_node, 'entry', 'arg1')
        BaseNode.connect(DataSourceNode(2), mod_node, 'data', 'arg2')
        BaseNode.connect(mod_node, eq_node, 'result', 'arg1')
        BaseNode.connect(DataSourceNode(0), eq_node, 'data', 'arg2')
        BaseNode.connect(eq_node, filter_node, 'result', 'keep')

        self.assertEqual([0, 2, 4, 6, 8],
                         filter_node.resolve_output('filtered'))
Exemplo n.º 11
0
 def test_node_output(self):
     map_node = MapNode()
     add_node = AddNode()
     BaseNode.connect(DataSourceNode([0, 1, 2, 3, 4]), map_node, 'data',
                      'array')
     BaseNode.connect(map_node, add_node, 'entry', 'arg1')
     BaseNode.connect(map_node, add_node, 'index', 'arg2')
     BaseNode.connect(add_node, map_node, 'result', 'value')
     self.assertEqual([0, 2, 4, 6, 8], map_node.resolve_output('mapped'))
Exemplo n.º 12
0
    def test_node_output(self):
        reduce_node = ReduceNode()
        BaseNode.connect(DataSourceNode([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
                         reduce_node, 'data', 'array')
        add_node = AddNode()
        BaseNode.connect(reduce_node, add_node, 'accumulator', 'arg1')
        BaseNode.connect(reduce_node, add_node, 'current', 'arg2')
        BaseNode.connect(add_node, reduce_node, 'result', 'accumulator')

        self.assertEqual(45, reduce_node.resolve_output('reduced'))
Exemplo n.º 13
0
 def test_or_true(self):
     or_node = OrNode()
     d1 = DataSourceNode(True)
     d2 = DataSourceNode(True)
     BaseNode.connect(d1, or_node, 'data', 'arg1')
     BaseNode.connect(d2, or_node, 'data', 'arg2')
     self.assertTrue(or_node.resolve_output('result'))
     d1.data = False
     self.assertTrue(or_node.resolve_output('result'))
     d1.data = True
     d2.data = False
     self.assertTrue(or_node.resolve_output('result'))
Exemplo n.º 14
0
    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'))
Exemplo n.º 15
0
 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'))
Exemplo n.º 16
0
 def test_and_false(self):
     and_node = AndNode()
     d1 = DataSourceNode(True)
     d2 = DataSourceNode(False)
     BaseNode.connect(d1, and_node, 'data', 'arg1')
     BaseNode.connect(d2, and_node, 'data', 'arg2')
     self.assertFalse(and_node.resolve_output('result'))
     d1.data = False
     self.assertFalse(and_node.resolve_output('result'))
     d2.data = True
     self.assertFalse(and_node.resolve_output('result'))
Exemplo n.º 17
0
 def test_string(self):
     input_str = 'abcdef123456'
     self.assertEqual(DataSourceNode(input_str).resolve_output('data'), input_str)
Exemplo n.º 18
0
 def test_value(self):
     input_str = 'abcdef123456'
     node = PassThroughNode()
     BaseNode.connect(DataSourceNode(input_str), node, 'data', 'in')
     self.assertEqual(node.resolve_output('out'), input_str)
Exemplo n.º 19
0
 def test_numbers(self):
     import math
     self.assertEqual(DataSourceNode(math.pi).resolve_output('data'), math.pi)
     self.assertEqual(DataSourceNode(4).resolve_output('data'), 4)
     self.assertEqual(DataSourceNode(-3.2).resolve_output('data'), -3.2)
Exemplo n.º 20
0
 def test_and_true(self):
     and_node = AndNode()
     BaseNode.connect(DataSourceNode(True), and_node, 'data', 'arg1')
     BaseNode.connect(DataSourceNode(True), and_node, 'data', 'arg2')
     self.assertTrue(and_node.resolve_output('result'))
Exemplo n.º 21
0
 def test_or_false(self):
     or_node = OrNode()
     BaseNode.connect(DataSourceNode(False), or_node, 'data', 'arg1')
     BaseNode.connect(DataSourceNode(False), or_node, 'data', 'arg2')
     self.assertFalse(or_node.resolve_output('result'))
Exemplo n.º 22
0
 def test_not_node_false(self):
     not_node = NotNode()
     BaseNode.connect(DataSourceNode(True), not_node, 'data', 'in')
     self.assertFalse(not_node.resolve_output('out'))
Exemplo n.º 23
0
def node_struct(node, input_values, input_names):
    for input_value, input_name in zip(input_values, input_names):
        BaseNode.connect(DataSourceNode(input_value), node, 'data', input_name)
    return node
Exemplo n.º 24
0
def operation_value(node, val1, val2, val1_name='arg1', val2_name='arg2'):
    BaseNode.connect(DataSourceNode(val1), node, 'data', val1_name)
    BaseNode.connect(DataSourceNode(val2), node, 'data', val2_name)
    return node.resolve_output('result')