def test_EvalField_editor(self):
        c = self.EvalFieldTest()

        codeGen = Python2CodeGenerator('test')

        c.x.constantValue = 10.0
        c.y.constantValue = 20.0

        self.assertEqual(10.0, c.x.getValueForEditor())
        self.assertEqual(20.0, c.y.getValueForEditor())

        self.assertEqual(
            Py.Call(target=Py.Load(name='C'),
                    args=[
                        Py.FloatLiteral(value='10.0'),
                        Py.FloatLiteral(value='20.0')
                    ]), c.__py_evalmodel__(codeGen))

        x_expr = EmbeddedPython2Expr.fromText('a+b')
        y_expr = EmbeddedPython2Expr.fromText('c+d')
        c.x.expr = x_expr
        c.y.expr = y_expr

        self.assertEqual(10.0, c.x.getValueForEditor())
        self.assertEqual(20.0, c.y.getValueForEditor())

        self.assertEqual(
            Py.Call(target=Py.Load(name='C'),
                    args=[x_expr.model, y_expr.model]),
            c.__py_evalmodel__(codeGen))
	def __init__(self):
		self._name = 'value'
		self._expr = EmbeddedPython2Expr()
		self._suite = None
		self._code = None
		self._incr = IncrementalValueMonitor()
		self.__change_history__ = None
    def test_ExprField_serialisation(self):
        x_expr = EmbeddedPython2Expr.fromText('a+b')
        d = self.ExprFieldTest(x=x_expr)

        d_io = pickle.loads(pickle.dumps(d))

        self.assertEqual(x_expr, d_io.x.expr)
    def test_EvalField_serialisation(self):
        c = self.EvalFieldTest()

        c.x.constantValue = 10.0
        c.y.constantValue = 20.0
        x_expr = EmbeddedPython2Expr.fromText('a+b')
        y_expr = EmbeddedPython2Expr.fromText('c+d')
        c.x.expr = x_expr
        c.y.expr = y_expr

        c_io = pickle.loads(pickle.dumps(c))

        self.assertEqual(10.0, c_io.x.constantValue)
        self.assertEqual(20.0, c_io.y.constantValue)
        self.assertEqual(x_expr, c_io.x.expr)
        self.assertEqual(y_expr, c_io.y.expr)
    def __init__(self, expr=None):
        if expr is None:
            expr = EmbeddedPython2Expr()
        self._expr = expr

        self._incr = IncrementalValueMonitor()
        self.__change_history__ = None
    def test_ExprField_py_evalmodel(self):
        x_expr = EmbeddedPython2Expr.fromText('a+b')
        d = self.ExprFieldTest(x=x_expr)

        codeGen = Python2CodeGenerator('test')

        self.assertEqual(
            Py.Call(target=Py.Load(name='D'), args=[x_expr.model]),
            d.__py_evalmodel__(codeGen))
    def test_EvalField_clipboardCopy(self):
        c = self.EvalFieldTest()

        c.x.constantValue = 10.0
        c.y.constantValue = 20.0
        x_expr = EmbeddedPython2Expr.fromText('a+b')
        y_expr = EmbeddedPython2Expr.fromText('c+d')
        c.x.expr = x_expr
        c.y.expr = y_expr

        c_io = ClipboardCopier.instance.copy(c)

        self.assertIsNot(c.x.expr, c_io.x.expr)
        self.assertIsNot(c.y.expr, c_io.y.expr)
        self.assertEqual(10.0, c_io.x.constantValue)
        self.assertEqual(20.0, c_io.y.constantValue)
        self.assertEqual(x_expr, c_io.x.expr)
        self.assertEqual(y_expr, c_io.y.expr)
    def __init__(self, field, object_instance, wrapped_source_value):
        super(ExprFieldInstance, self).__init__(field, object_instance,
                                                wrapped_source_value)

        if wrapped_source_value is None:
            source_value = EmbeddedPython2Expr()
        else:
            source_value = wrapped_source_value[0]

        self.__expr = source_value
 def __init__(self):
     self._target = EmbeddedPython2Target()
     self._value = EmbeddedPython2Expr()
     self._incr = IncrementalValueMonitor()
     self.__change_history__ = None
 def _onAdd(button, event):
     self.expr = EmbeddedPython2Expr()
    def test_EvalField_changeHistory(self):
        c = self.EvalFieldTest()

        self.assertEqual(0, self.ch.getNumUndoChanges())
        self.assertEqual(0, self.ch.getNumRedoChanges())

        self.ch.track(c)

        self.assertIs(ChangeHistory.getChangeHistoryFor(c), self.ch)

        self.assertEqual(0, self.ch.getNumUndoChanges())
        self.assertEqual(0, self.ch.getNumRedoChanges())

        c.x.constantValue = 10.0
        c.y.constantValue = 20.0

        self.assertEqual(10.0, c.x.constantValue)
        self.assertEqual(20.0, c.y.constantValue)
        self.assertIsNone(c.x.expr)
        self.assertIsNone(c.y.expr)
        self.assertEqual(2, self.ch.getNumUndoChanges())

        x_expr = EmbeddedPython2Expr.fromText('a+b')
        y_expr = EmbeddedPython2Expr.fromText('c+d')

        self.assertIs(ChangeHistory.getChangeHistoryFor(x_expr), None)
        self.assertIs(ChangeHistory.getChangeHistoryFor(y_expr), None)

        c.x.expr = x_expr
        c.y.expr = y_expr

        self.assertIs(ChangeHistory.getChangeHistoryFor(x_expr), self.ch)
        self.assertIs(ChangeHistory.getChangeHistoryFor(y_expr), self.ch)

        self.assertEqual(10.0, c.x.constantValue)
        self.assertEqual(20.0, c.y.constantValue)
        self.assertIs(x_expr, c.x.expr)
        self.assertIs(y_expr, c.y.expr)
        self.assertEqual(4, self.ch.getNumUndoChanges())

        self.ch.undo()

        self.assertEqual(10.0, c.x.constantValue)
        self.assertEqual(20.0, c.y.constantValue)
        self.assertIs(x_expr, c.x.expr)
        self.assertIsNone(c.y.expr)
        self.assertEqual(3, self.ch.getNumUndoChanges())

        self.ch.undo()

        self.assertEqual(10.0, c.x.constantValue)
        self.assertEqual(20.0, c.y.constantValue)
        self.assertIsNone(c.x.expr)
        self.assertIsNone(c.y.expr)
        self.assertEqual(2, self.ch.getNumUndoChanges())

        self.ch.undo()

        self.assertEqual(10.0, c.x.constantValue)
        self.assertEqual(1.0, c.y.constantValue)
        self.assertIsNone(c.x.expr)
        self.assertIsNone(c.y.expr)
        self.assertEqual(1, self.ch.getNumUndoChanges())

        self.ch.undo()

        self.assertEqual(0.0, c.x.constantValue)
        self.assertEqual(1.0, c.y.constantValue)
        self.assertIsNone(c.x.expr)
        self.assertIsNone(c.y.expr)
        self.assertEqual(0, self.ch.getNumUndoChanges())