def test_mapper_with_pruning(self): """ A test case to check that the mapper works even in the case of pruning. """ # A mock RDF object t = CallableGeneratorTest.Temp() # Head node node = Node(None, None) # Set of operations to build the graph n1 = node.Define() n2 = node.Filter().Filter() n4 = n2.Count() n5 = n1.Count() n6 = node.Filter() n5 = n1.Filter() # Reason for pruning (change of reference) # Generate and execute the mapper generator = CallableGenerator(node) mapper_func = generator.get_callable() values = mapper_func(t) nodes = generator.get_action_nodes() reqd_order = [1, 2, 2, 2, 3, 2] # Assertions self.assertEqual(t.ord_list, reqd_order) self.assertListEqual(nodes, [n4.action_node]) self.assertListEqual(values, [t])
def test_dfs_graph_with_computed_values_pruning(self): """ """ # Head node node = Node(None, None) # Graph nodes n1 = node.Define() n2 = node.Filter() n3 = n2.Filter() n4 = n3.Count() n5 = n1.Filter() n6 = n5.Count() n7 = node.Filter() # This is to make sure action nodes with # already computed values are pruned. n6.action_node.value = 1 # This is to make sure that transformation # leaf nodes with value (possibly set intentionally) # don't get pruned. n7.value = 1 obtained_order = DfsTest.traverse(node=node.get_head()) # The node 'n6' will be pruned. Hence, # there's only one '3' in this list. reqd_order = [1, 2, 2, 2, 3, 2] self.assertEqual(obtained_order, reqd_order)
def test_mapper_from_graph(self): """ A simple test case to check the working of mapper. """ # A mock RDF object t = CallableGeneratorTest.Temp() # Head node node = Node(None, None) # Set of operations to build the graph n1 = node.Define() n2 = node.Filter().Filter() n4 = n2.Count() n5 = n1.Count() n6 = node.Filter() # Generate and execute the mapper generator = CallableGenerator(node) mapper_func = generator.get_callable() values = mapper_func(t) nodes = generator.get_action_nodes() reqd_order = [1, 3, 2, 2, 3, 2] # Assertions self.assertEqual(t.ord_list, reqd_order) self.assertListEqual(nodes, [n5.action_node, n4.action_node]) self.assertListEqual(values, [t, t])
def test_dfs_graph_with_parent_pruning(self): """ Test case to check that parent nodes with no user references don't get pruned. """ # Head node node = Node(None, None) # Graph nodes n1 = node.Define() n2 = node.Filter() n3 = n2.Filter() n4 = n3.Count() n5 = n1.Filter() n6 = node.Filter() # Remove references from n2 (which shouldn't affect the graph) n2 = None obtained_order = DfsTest.traverse(node=node.get_head()) reqd_order = [1, 2, 2, 2, 3, 2] # Removing references from n2 will not prune any node # because n2 still has children self.assertEqual(obtained_order, reqd_order)
def test_dfs_graph_with_recursive_pruning(self): """ Test case to check that nodes in a PyRDF graph with no user references and no children get pruned recursively. """ # Head node node = Node(None, None) # Graph nodes n1 = node.Define() n2 = node.Filter() n3 = n2.Filter() n4 = n3.Count() n5 = n1.Filter() n6 = node.Filter() # Remove references from n4 and it's parent nodes n4 = n3 = n2 = None obtained_order = DfsTest.traverse(node=node.get_head()) reqd_order = [1, 2, 2] self.assertEqual(obtained_order, reqd_order)
def test_dfs_graph_with_pruning_transformations(self): """ Test case to check that transformation nodes with no children and no user references get pruned. """ # Head node node = Node(None, None) # Graph nodes n1 = node.Define() n2 = node.Filter() n3 = n2.Filter() n4 = n3.Count() n5 = n1.Filter() n6 = node.Filter() # Transformation pruning n5 = n1.Count() # n5 was earlier a transformation node obtained_order = DfsTest.traverse(node=node.get_head()) reqd_order = [1, 3, 2, 2, 3, 2] self.assertEqual(obtained_order, reqd_order)
def test_node_pickle(self): """ Test cases to check that nodes can be accurately pickled and un-pickled. """ import pickle # Node definitions node = Node(None, None) # Head node n1 = node.Define("a", b="c") # First child node n2 = n1.Count() n3 = node.Filter("b") n4 = n3.Count() # Pickled representation of nodes pickled_node = pickle.dumps(node) pickled_n3 = pickle.dumps(n3) # Un-pickled node objects unpickled_node = pickle.loads(pickled_node) unpickled_n3 = pickle.loads(pickled_n3) self.assertIsInstance(unpickled_node, type(node)) self.assertIsInstance(unpickled_n3, type(n3)) self.assertGraphs(node, unpickled_node) self.assertGraphs(n3, unpickled_n3)
def test_dfs_graph_without_pruning(self): """ Test case to check that node pruning does not occur if every node either has children or some user references. """ # Head node node = Node(None, None) # Graph nodes n1 = node.Define() n2 = node.Filter() n3 = n2.Filter() n4 = n3.Count() n5 = n1.Count() n6 = node.Filter() obtained_order = DfsTest.traverse(node=node.get_head()) reqd_order = [1, 3, 2, 2, 3, 2] self.assertEqual(obtained_order, reqd_order)