class OverrideTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext() global num_calls_A, num_calls_A_override num_calls_A = 0 num_calls_A_override = 0 def test_override(self): b = self.ctx[B] = 1 c = self.ctx[C] = 2 self.assertEqual(self.ctx[A], b) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 0) # override A self.ctx[A] = A_override self.assertEqual(self.ctx[A], c) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 1) # check the dependencies are working c = self.ctx[C] = 100 self.assertEqual(self.ctx[A], c) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 2) # check A doesn't still depend on B b = self.ctx[B] = 500 self.assertEqual(self.ctx[A], c) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 2) def test_shift_override(self): b = self.ctx[B] = 1 c = self.ctx[C] = 2 # D = A * 2 # A = B self.assertEqual(self.ctx[D], b * 2) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 0) # shift_test = D [ A := A_override ] # A_override = C self.assertEqual(self.ctx[shift_test], c * 2) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 1) def test_shift_override2(self): c = self.ctx[C] = 10 # shift_test = D [ B := B_override ] # D = A * 2 # A = B # B_override = C * 3 self.assertEqual(self.ctx[shift_test2], c * 6) def test_shift_override3(self): # overriding a node in the root context and then # evaluating it in a shifted context should work self.ctx[D] = D_override # = A + C self.ctx[A] = 10 self.ctx[C] = 20 shifted_ctx = self.ctx.shift({A: 100}) # - if D is used instead of D_override A will equal 2 * 100 = 200 # - if D_override is used but in the root context the # result will be A + C = 30 # - if D_override is used and the correct context is used # the results will be A + C = 100 + 20 = 120 self.assertEqual(shifted_ctx[D], 120)
class OverrideTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext() global num_calls_A, num_calls_A_override num_calls_A = 0 num_calls_A_override = 0 def test_override(self): b = self.ctx[B] = 1 c = self.ctx[C] = 2 self.assertEqual(self.ctx[A], b) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 0) # override A self.ctx[A] = A_override self.assertEqual(self.ctx[A], c) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 1) # check the dependencies are working c = self.ctx[C] = 100 self.assertEqual(self.ctx[A], c) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 2) # check A doesn't still depend on B b = self.ctx[B] = 500 self.assertEqual(self.ctx[A], c) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 2) def test_shift_override(self): b = self.ctx[B] = 1 c = self.ctx[C] = 2 # D = A * 2 # A = B self.assertEqual(self.ctx[D], b * 2) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 0) # shift_test = D [ A := A_override ] # A_override = C self.assertEqual(self.ctx[shift_test], c * 2) self.assertEqual(num_calls_A, 1) self.assertEqual(num_calls_A_override, 1) def test_shift_override2(self): c = self.ctx[C] = 10 # shift_test = D [ B := B_override ] # D = A * 2 # A = B # B_override = C * 3 self.assertEqual(self.ctx[shift_test2], c * 6) def test_shift_override3(self): # overriding a node in the root context and then # evaluating it in a shifted context should work self.ctx[D] = D_override # = A + C self.ctx[A] = 10 self.ctx[C] = 20 shifted_ctx = self.ctx.shift({A : 100}) # - if D is used instead of D_override A will equal 2 * 100 = 200 # - if D_override is used but in the root context the # result will be A + C = 30 # - if D_override is used and the correct context is used # the results will be A + C = 100 + 20 = 120 self.assertEqual(shifted_ctx[D], 120)
class NodeExtensionsTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext(datetime.now()) self.ctx[D] = 10 self.ctx[E] = 20 def test_node_names(self): self.assertEqual(A.short_name, "A") self.assertEqual(B.short_name, "B") self.assertEqual(C.short_name, "C") self.assertEqual(D.short_name, "D") self.assertEqual(E.short_name, "E") self.assertEqual(F.short_name, "F") def test_eval(self, ctx=None): ctx = ctx or self.ctx # get the calculated value A a = ctx[A] # calcualte the expected value b = ctx[D] * ctx[E] c = ctx[now].year - 1970 expected_a = b + c self.assertEqual(a, expected_a) def test_update(self, ctx=None): ctx = ctx or self.ctx orig_b = ctx[B] ctx[D] *= 2 self.assertEqual(orig_b * 2, ctx[B]) b = ctx[D] * ctx[E] c = ctx[now].year - 1970 expected_a = b + c self.assertEqual(ctx[A], expected_a) def test_clone(self): # get A before doing anything orig_a = self.ctx[A] # clone the context and run the eval and update checks new_date = self.ctx[now] + timedelta(days=365) shifted_ctx = self.ctx.shift({now: new_date}) self.test_eval(shifted_ctx) # shifted contexts are read-only self.assertRaises(AttributeError, lambda: self.test_update(shifted_ctx)) # check the original hasn't been affected self.assertEqual(orig_a, self.ctx[A]) def test_shift(self): # get A before doing anything orig_a = self.ctx[A] # shift the context and run the eval check shifted_ctx = self.ctx.shift({E: self.ctx[E] * 2}) self.assertEqual(shifted_ctx[E], self.ctx[E] * 2) self.test_eval(shifted_ctx) # check the original hasn't been affected self.assertEqual(orig_a, self.ctx[A]) def test_set_evalnode(self): # setting an evalnode should fix its value self.ctx[A] = 100 self.assertEqual(self.ctx[A], 100) # changing its dependencies shouldn't affect it self.ctx[B] *= 2 self.ctx[C] *= 2 self.assertEqual(self.ctx[A], 100)
class NodeExtensionsTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext(datetime.now()) self.ctx[D] = 10 self.ctx[E] = 20 def test_node_names(self): self.assertEqual(A.short_name, "A") self.assertEqual(B.short_name, "B") self.assertEqual(C.short_name, "C") self.assertEqual(D.short_name, "D") self.assertEqual(E.short_name, "E") self.assertEqual(F.short_name, "F") def test_eval(self, ctx=None): ctx = ctx or self.ctx # get the calculated value A a = ctx[A] # calcualte the expected value b = ctx[D] * ctx[E] c = ctx[now].year - 1970 expected_a = b + c self.assertEqual(a, expected_a) def test_update(self, ctx=None): ctx = ctx or self.ctx orig_b = ctx[B] ctx[D] *= 2 self.assertEqual(orig_b * 2, ctx[B]) b = ctx[D] * ctx[E] c = ctx[now].year - 1970 expected_a = b + c self.assertEqual(ctx[A], expected_a) def test_clone(self): # get A before doing anything orig_a = self.ctx[A] # clone the context and run the eval and update checks new_date = self.ctx[now] + timedelta(days=365) shifted_ctx = self.ctx.shift({now : new_date}) self.test_eval(shifted_ctx) # shifted contexts are read-only self.assertRaises(AttributeError, lambda: self.test_update(shifted_ctx)) # check the original hasn't been affected self.assertEqual(orig_a, self.ctx[A]) def test_shift(self): # get A before doing anything orig_a = self.ctx[A] # shift the context and run the eval check shifted_ctx = self.ctx.shift({E : self.ctx[E] * 2}) self.assertEqual(shifted_ctx[E], self.ctx[E] * 2) self.test_eval(shifted_ctx) # check the original hasn't been affected self.assertEqual(orig_a, self.ctx[A]) def test_set_evalnode(self): # setting an evalnode should fix its value self.ctx[A] = 100 self.assertEqual(self.ctx[A], 100) # changing its dependencies shouldn't affect it self.ctx[B] *= 2 self.ctx[C] *= 2 self.assertEqual(self.ctx[A], 100)
class PickleTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext() def test_pickle(self): a = self.ctx[A] = 10 b = self.ctx[B] c = self.ctx[C] num_calls = _b_num_calls x = pickle.dumps(self.ctx) new_ctx = pickle.loads(x) self.assertEquals(new_ctx[A], a) self.assertEquals(new_ctx[B], b) self.assertEquals(new_ctx[C], c) # unpickling the context shouldn't re-evaluate anything self.assertEquals(num_calls, _b_num_calls) def test_node_method_pickle(self): # get another node via a nodetype method # use nan in the args as there were problems pickling/unpicking nan node = A.samplenode(initial_value=np.nan, offset=pa.datetools.BMonthEnd()) # test text and binary pickle formats for protocol in (0, pickle.HIGHEST_PROTOCOL): x = pickle.dumps(node, protocol) new_node = pickle.loads(x) # unpickling a node constructed via a notetype method call should retrieve # the same node instance self.assertTrue(node is new_node) def test_shifted_pickle(self): shifted_ctx = self.ctx.shift({A : 100}) a = shifted_ctx[A] b = shifted_ctx[B] c = shifted_ctx[C] num_calls = _b_num_calls x = pickle.dumps(self.ctx) new_ctx = pickle.loads(x) # pickling preserves shifted contexts so this should return # an existing shifted context new_shifted_ctx = new_ctx.shift({A : a}) self.assertNotEquals(new_shifted_ctx, shifted_ctx) self.assertEquals(new_shifted_ctx[A], a) self.assertEquals(new_shifted_ctx[B], b) self.assertEquals(new_shifted_ctx[C], c) # unpickling the context shouldn't re-evaluate anything self.assertEquals(num_calls, _b_num_calls) def test_dynamic_varnode_pickle(self): # shift B by a temporary varnode with a value set in the root context temp_varnode = varnode(default="temp_varnode_default") shifted_ctx = self.ctx.shift({B : temp_varnode}) self.ctx[temp_varnode] = "temp_varnode" self.assertEquals(shifted_ctx[B], "temp_varnode") # pickle the context, unregister the node and recreate the context x = pickle.dumps(self.ctx) MDFContext.unregister_node(temp_varnode) new_ctx = pickle.loads(x) # find the shifted context (can't reshift as temp_varnode was unregistered) self.assertEquals(len(new_ctx.get_shifted_contexts()), 1) shifted_ctx = new_ctx.get_shifted_contexts()[0] # check that B in the shifted context is still set self.assertEquals(shifted_ctx[B], "temp_varnode") # check that temp_varnode refers to the original node, not the new one # that had to be recreated when un-pickled. self.assertEquals(shifted_ctx[temp_varnode], "temp_varnode_default") def test_save(self): tmpdir = tempfile.mkdtemp() try: for ext in (".dag", ".zip", ".bz2", ".gz"): filename = os.path.join(tmpdir, "ctx" + ext) a = self.ctx[A] = random.randint(0, 100) self.assertEquals(self.ctx[A], a) self.ctx.save(filename) _logger.info("context file '%s' is %db" % (os.path.basename(filename), os.stat(filename).st_size)) new_ctx = MDFContext.load(filename) self.assertEquals(new_ctx[A], a) os.unlink(filename) finally: shutil.rmtree(tmpdir, True)
class PickleTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext() def test_pickle(self): a = self.ctx[A] = 10 b = self.ctx[B] c = self.ctx[C] num_calls = _b_num_calls x = pickle.dumps(self.ctx) new_ctx = pickle.loads(x) self.assertEquals(new_ctx[A], a) self.assertEquals(new_ctx[B], b) self.assertEquals(new_ctx[C], c) # unpickling the context shouldn't re-evaluate anything self.assertEquals(num_calls, _b_num_calls) def test_node_method_pickle(self): # get another node via a nodetype method # use nan in the args as there were problems pickling/unpicking nan node = A.samplenode(initial_value=np.nan, offset=pa.datetools.BMonthEnd()) # test text and binary pickle formats for protocol in (0, pickle.HIGHEST_PROTOCOL): x = pickle.dumps(node, protocol) new_node = pickle.loads(x) # unpickling a node constructed via a notetype method call should retrieve # the same node instance self.assertTrue(node is new_node) def test_shifted_pickle(self): shifted_ctx = self.ctx.shift({A: 100}) a = shifted_ctx[A] b = shifted_ctx[B] c = shifted_ctx[C] num_calls = _b_num_calls x = pickle.dumps(self.ctx) new_ctx = pickle.loads(x) # pickling preserves shifted contexts so this should return # an existing shifted context new_shifted_ctx = new_ctx.shift({A: a}) self.assertNotEquals(new_shifted_ctx, shifted_ctx) self.assertEquals(new_shifted_ctx[A], a) self.assertEquals(new_shifted_ctx[B], b) self.assertEquals(new_shifted_ctx[C], c) # unpickling the context shouldn't re-evaluate anything self.assertEquals(num_calls, _b_num_calls) def test_dynamic_varnode_pickle(self): # shift B by a temporary varnode with a value set in the root context temp_varnode = varnode(default="temp_varnode_default") shifted_ctx = self.ctx.shift({B: temp_varnode}) self.ctx[temp_varnode] = "temp_varnode" self.assertEquals(shifted_ctx[B], "temp_varnode") # pickle the context, unregister the node and recreate the context x = pickle.dumps(self.ctx) MDFContext.unregister_node(temp_varnode) new_ctx = pickle.loads(x) # find the shifted context (can't reshift as temp_varnode was unregistered) self.assertEquals(len(new_ctx.get_shifted_contexts()), 1) shifted_ctx = new_ctx.get_shifted_contexts()[0] # check that B in the shifted context is still set self.assertEquals(shifted_ctx[B], "temp_varnode") # check that temp_varnode refers to the original node, not the new one # that had to be recreated when un-pickled. self.assertEquals(shifted_ctx[temp_varnode], "temp_varnode_default") def test_save(self): tmpdir = tempfile.mkdtemp() try: for ext in (".dag", ".zip", ".bz2", ".gz"): filename = os.path.join(tmpdir, "ctx" + ext) a = self.ctx[A] = random.randint(0, 100) self.assertEquals(self.ctx[A], a) self.ctx.save(filename) _logger.info( "context file '%s' is %db" % (os.path.basename(filename), os.stat(filename).st_size)) new_ctx = MDFContext.load(filename) self.assertEquals(new_ctx[A], a) os.unlink(filename) finally: shutil.rmtree(tmpdir, True)