def test_simple_cache(self):
        signature = EnsembleSignature(
            signatures=[ParentChildByNameTopologySignature()])
        cache = signature.signature_cache_class()

        for node in simple_unique_node_tree().nodes():
            tokens = signature.get_signature(node, parent=node.parent())
            if not cache.node_count():
                # nothing added yet
                self.assertEqual([], cache.multiplicity(signature=tokens))
            else:
                self.assertEqual([0], cache.multiplicity(signature=tokens))
            cache[tokens, ProcessStartEvent] = {"value": 0}
            self.assertEqual([1], cache.multiplicity(signature=tokens))
        self.assertEqual([4], cache.node_count())
        self.assertEqual([4], cache.multiplicity())

        signature = EnsembleSignature(
            signatures=[ParentChildByNameTopologySignature()])
        cache = signature.signature_cache_class()

        for node in simple_monitoring_tree().nodes():
            cache[signature.get_signature(node, parent=node.parent()),
                  ProcessStartEvent] = {
                      "value": 0
                  }
        self.assertEqual([3], cache.node_count())
        self.assertEqual([4], cache.multiplicity())
    def test_simple_prototype_cache(self):
        signature = EnsembleSignature(
            signatures=[ParentChildByNameTopologySignature()])
        cache = signature.prototype_signature_cache_class(
            supported={ProcessExitEvent: True})

        tree = simple_unique_node_tree()
        for node in tree.nodes():
            tokens = signature.get_signature(node, parent=node.parent())
            if not cache.node_count():
                # nothing added yet
                self.assertEqual([], cache.get(signature=tokens))
            else:
                self.assertTrue(
                    isinstance(cache.get(signature=tokens)[0], dict))
            cache[tokens, tree, ProcessExitEvent] = {"value": 1}
            stats = cache.get_statistics(signature=tokens,
                                         prototype=tree,
                                         key="value",
                                         event_type=ProcessExitEvent)
            self.assertTrue(stats[0].count() >= 1)
        self.assertEqual([4], cache.node_count())
        self.assertEqual([4], cache.multiplicity())

        signature = EnsembleSignature(
            signatures=[ParentChildByNameTopologySignature()])
        cache = signature.signature_cache_class()

        for node in simple_monitoring_tree().nodes():
            cache[signature.get_signature(node, parent=node.parent()),
                  ProcessStartEvent] = {
                      "value": 0
                  }
        self.assertEqual([3], cache.node_count())
        self.assertEqual([4], cache.multiplicity())
    def test_two_ensembles_different_frequency(self):
        signature = EnsembleSignature(signatures=[
            ParentChildByNameTopologySignature(),
            ParentChildOrderTopologySignature()
        ])
        cache = signature.signature_cache_class()

        for node in simple_monitoring_tree().nodes():
            cache[signature.get_signature(node, parent=node.parent()),
                  ProcessStartEvent] = {
                      "value": 0
                  }
        self.assertEqual([3, 4], cache.node_count())
        self.assertEqual([4, 4], cache.multiplicity())
    def test_two_ensembles(self):
        signature = EnsembleSignature(signatures=[
            ParentChildByNameTopologySignature(),
            ParentChildOrderTopologySignature()
        ])
        cache = signature.signature_cache_class()

        for node in simple_unique_node_tree().nodes():
            tokens = signature.get_signature(node, parent=node.parent())
            if not cache.node_count():
                self.assertEqual([], cache.multiplicity(signature=tokens))
            else:
                self.assertEqual([0, 0], cache.multiplicity(signature=tokens))
            cache[tokens, ProcessStartEvent] = {"value": 0}
            self.assertEqual([1, 1], cache.multiplicity(signature=tokens))
        self.assertEqual([4, 4], cache.node_count())
        self.assertEqual([4, 4], cache.multiplicity())
 def test_creation(self):
     signature = EnsembleSignature(
         signatures=[ParentChildByNameTopologySignature()])
     cache = signature.signature_cache_class()
     self.assertTrue(isinstance(cache, EnsembleSignatureCache))