Esempio n. 1
0
    def test_get_node_addr(self):
        # Signature: name(self)
                # Get the namespace address of this component

        d = ComponentClass(name='D',)
        e = ComponentClass(name='E')
        f = ComponentClass(name='F')
        g = ComponentClass(name='G')
        b = ComponentClass(name='B', subnodes={'d': d, 'e': e})
        c = ComponentClass(name='C', subnodes={'f': f, 'g': g})
        a = ComponentClass(name='A', subnodes={'b': b, 'c': c})

        # Construction of the objects causes cloning to happen:
        # Therefore we test by looking up and checking that there
        # are the correct component names:
        bNew = a.get_subnode('b')
        cNew = a.get_subnode('c')
        dNew = a.get_subnode('b.d')
        eNew = a.get_subnode('b.e')
        fNew = a.get_subnode('c.f')
        gNew = a.get_subnode('c.g')

        self.assertEquals(a.get_node_addr(),
                          NamespaceAddress.create_root())
        self.assertEquals(bNew.get_node_addr(),
                          NamespaceAddress('b'))
        self.assertEquals(cNew.get_node_addr(),
                          NamespaceAddress('c'))
        self.assertEquals(dNew.get_node_addr(),
                          NamespaceAddress('b.d'))
        self.assertEquals(eNew.get_node_addr(),
                          NamespaceAddress('b.e'))
        self.assertEquals(fNew.get_node_addr(),
                          NamespaceAddress('c.f'))
        self.assertEquals(gNew.get_node_addr(),
                          NamespaceAddress('c.g'))

        self.assertEquals(a.name, 'A')
        self.assertEquals(bNew.name, 'B')
        self.assertEquals(cNew.name, 'C')
        self.assertEquals(dNew.name, 'D')
        self.assertEquals(eNew.name, 'E')
        self.assertEquals(fNew.name, 'F')
        self.assertEquals(gNew.name, 'G')
Esempio n. 2
0
    def test_insert_subnode(self):
        # Signature: name(self, subnode, namespace)
                # Insert a subnode into this component
                #
                #
                # :param subnode: An object of type ``ComponentClass``.
                # :param namespace: A `string` specifying the name of the component in
                #     this components namespace.
                #
                # :raises: ``NineMLRuntimeException`` if there is already a subcomponent at
                #     the same namespace location
                #
                # .. note::
                #
                #     This method will clone the subnode.

        d = ComponentClass(name='D')
        e = ComponentClass(name='E')
        f = ComponentClass(name='F')
        g = ComponentClass(name='G')

        b = ComponentClass(name='B')
        b.insert_subnode(namespace='d', subnode=d)
        b.insert_subnode(namespace='e', subnode=e)

        c = ComponentClass(name='C')
        c.insert_subnode(namespace='f', subnode=f)
        c.insert_subnode(namespace='g', subnode=g)

        a = ComponentClass(name='A')
        a.insert_subnode(namespace='b', subnode=b)
        a.insert_subnode(namespace='c', subnode=c)

        # Construction of the objects causes cloning to happen:
        # Therefore we test by looking up and checking that there
        # are the correct component names:
        bNew = a.get_subnode('b')
        cNew = a.get_subnode('c')
        dNew = a.get_subnode('b.d')
        eNew = a.get_subnode('b.e')
        fNew = a.get_subnode('c.f')
        gNew = a.get_subnode('c.g')

        self.assertEquals(a.get_node_addr(),
                          NamespaceAddress.create_root())
        self.assertEquals(bNew.get_node_addr(),
                          NamespaceAddress('b'))
        self.assertEquals(cNew.get_node_addr(),
                          NamespaceAddress('c'))
        self.assertEquals(dNew.get_node_addr(),
                          NamespaceAddress('b.d'))
        self.assertEquals(eNew.get_node_addr(),
                          NamespaceAddress('b.e'))
        self.assertEquals(fNew.get_node_addr(),
                          NamespaceAddress('c.f'))
        self.assertEquals(gNew.get_node_addr(),
                          NamespaceAddress('c.g'))

        self.assertEquals(a.name, 'A')
        self.assertEquals(bNew.name, 'B')
        self.assertEquals(cNew.name, 'C')
        self.assertEquals(dNew.name, 'D')
        self.assertEquals(eNew.name, 'E')
        self.assertEquals(fNew.name, 'F')
        self.assertEquals(gNew.name, 'G')

        self.assertRaises(NineMLRuntimeError, a.get_subnode, 'x')
        self.assertRaises(NineMLRuntimeError, a.get_subnode, 'a.')
        self.assertRaises(NineMLRuntimeError, a.get_subnode, 'a.X')
        self.assertRaises(NineMLRuntimeError, a.get_subnode, 'a.b.')
        self.assertRaises(NineMLRuntimeError, a.get_subnode, 'a.b.X')

        # Adding to the same namespace twice:
        d1 = ComponentClass(name='D1')
        d2 = ComponentClass(name='D2')
        a = ComponentClass(name='B')

        a.insert_subnode(namespace='d', subnode=d1)
        self.assertRaises(
            NineMLRuntimeError,
            a.insert_subnode, namespace='d', subnode=d2)