atomcontainertest.java

化学图形处理软件

        acetone.addBond(b1);
        acetone.addBond(b2);
        acetone.addBond(b3);
        
        assertEquals(3, acetone.getElectronContainerCount());
	
        acetone.removeAllElectronContainers();
        assertEquals(0, acetone.getElectronContainerCount());
    }
    
//    public void testSetElectronContainerCount_int() {
//        IAtomContainer container = builder.newAtomContainer();
//        container.setElectronContainerCount(2);
//        
//        assertEquals(2, container.getElectronContainerCount());
//    }
    
//    public void testSetAtomCount_int() {
//        IAtomContainer container = builder.newAtomContainer();
//        container.setAtomCount(2);
//        
//        assertEquals(2, container.getAtomCount());
//    }
    
//    public void testGetAtoms() {
//        // acetone molecule
//        IMolecule acetone = builder.newMolecule();
//        IAtom c1 = builder.newAtom("C");
//        IAtom c2 = builder.newAtom("C");
//        IAtom o = builder.newAtom("O");
//        IAtom c3 = builder.newAtom("C");
//        acetone.addAtom(c1);
//        acetone.addAtom(c2);
//        acetone.addAtom(c3);
//        acetone.addAtom(o);
//        
//        assertEquals(4, acetone.getAtoms().length);
//    }
    
    public void testAddAtom_IAtom() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);
        
        java.util.Iterator atomIter = acetone.atoms();
        int counter = 0;
        while (atomIter.hasNext()) {
            atomIter.next();
            counter++;
        }
        assertEquals(4, counter);
        
        // test force growing of default arrays
        for (int i=0; i<11; i++) {
        	acetone.addAtom(builder.newAtom());
        	acetone.addBond(builder.newBond());
        }
    }

    public void testAtoms() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);
        
        java.util.Iterator atomIter = acetone.atoms();
        assertNotNull(atomIter);
        assertTrue(atomIter.hasNext());
        IAtom next = (IAtom)atomIter.next();
        assertTrue(next instanceof IAtom);
        assertEquals(c1, next);
        assertTrue(atomIter.hasNext());
        next = (IAtom)atomIter.next();
        assertTrue(next instanceof IAtom);
        assertEquals(c2, next);
        assertTrue(atomIter.hasNext());
        next = (IAtom)atomIter.next();
        assertTrue(next instanceof IAtom);
        assertEquals(c3, next);
        assertTrue(atomIter.hasNext());
        next = (IAtom)atomIter.next();
        assertTrue(next instanceof IAtom);
        assertEquals(o, next);
        
        assertFalse(atomIter.hasNext());
    }

    public void testBonds() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);

        IBond bond1 = builder.newBond(c1,c2,1);
        IBond bond2 = builder.newBond(c2,o,2);
        IBond bond3 = builder.newBond(c2,c3,1);
        acetone.addBond(bond1);
        acetone.addBond(bond2);
        acetone.addBond(bond3);

        java.util.Iterator bonds = acetone.bonds();
        assertNotNull(bonds);
        assertTrue(bonds.hasNext());

        IBond next =  (IBond) bonds.next();
        assertTrue(next instanceof IBond);
        assertEquals(bond1, next);

        next = (IBond) bonds.next();
        assertTrue(next instanceof IBond);
        assertEquals(bond2, next);

        next = (IBond) bonds.next();
        assertTrue(next instanceof IBond);
        assertEquals(bond3, next);

        assertFalse(bonds.hasNext());
    }
    
    public void testLonePairs() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);

        IBond bond1 = builder.newBond(c1,c2,1);
        IBond bond2 = builder.newBond(c2,o,2);
        IBond bond3 = builder.newBond(c2,c3,1);
        acetone.addBond(bond1);
        acetone.addBond(bond2);
        acetone.addBond(bond3);
        ILonePair lp1 = builder.newLonePair(o);
        ILonePair lp2 = builder.newLonePair(o);
        acetone.addLonePair(lp1);
        acetone.addLonePair(lp2);

        java.util.Iterator lonePairs = acetone.lonePairs();
        assertNotNull(lonePairs);
        assertTrue(lonePairs.hasNext());

        ILonePair next =  (ILonePair) lonePairs.next();
        assertTrue(next instanceof ILonePair);
        assertEquals(lp1, next);

        next =  (ILonePair) lonePairs.next();
        assertTrue(next instanceof ILonePair);
        assertEquals(lp2, next);

        assertFalse(lonePairs.hasNext());
    }

    public void testSingleElectrons() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);

        IBond bond1 = builder.newBond(c1,c2,1);
        IBond bond2 = builder.newBond(c2,o,2);
        IBond bond3 = builder.newBond(c2,c3,1);
        acetone.addBond(bond1);
        acetone.addBond(bond2);
        acetone.addBond(bond3);
        ISingleElectron se1 = builder.newSingleElectron(o);
        ISingleElectron se2 = builder.newSingleElectron(c1);
        acetone.addSingleElectron(se1);
        acetone.addSingleElectron(se2);

        java.util.Iterator singleElectrons = acetone.singleElectrons();
        assertNotNull(singleElectrons);
        assertTrue(singleElectrons.hasNext());

        ISingleElectron next =  (ISingleElectron) singleElectrons.next();
        assertTrue(next instanceof ISingleElectron);
        assertEquals(se1, next);

        next =  (ISingleElectron) singleElectrons.next();
        assertTrue(next instanceof ISingleElectron);
        assertEquals(se2, next);

        assertFalse(singleElectrons.hasNext());
    }
    
    public void testElectronContainers() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);

        IBond bond1 = builder.newBond(c1,c2,1);
        IBond bond2 = builder.newBond(c2,o,2);
        IBond bond3 = builder.newBond(c2,c3,1);
        acetone.addBond(bond1);
        acetone.addBond(bond2);
        acetone.addBond(bond3);
        ISingleElectron se1 = builder.newSingleElectron(c1);
        ISingleElectron se2 = builder.newSingleElectron(c2);
        acetone.addSingleElectron(se1);
        acetone.addSingleElectron(se2);
        ILonePair lp1 = builder.newLonePair(o);
        ILonePair lp2 = builder.newLonePair(o);
        acetone.addLonePair(lp1);
        acetone.addLonePair(lp2);

        java.util.Iterator electronContainers = acetone.electronContainers();
        assertNotNull(electronContainers);
        assertTrue(electronContainers.hasNext());
        electronContainers.next();
        electronContainers.next();
        IElectronContainer ec = (IElectronContainer)electronContainers.next();
        assertTrue(ec instanceof IBond);
        assertEquals(bond3, ec);
        electronContainers.next();
        ILonePair lp = (ILonePair)electronContainers.next();
        assertTrue(lp instanceof ILonePair);
        assertEquals(lp2, lp);
        electronContainers.remove();
        ISingleElectron se =  (ISingleElectron)electronContainers.next();
        assertTrue(se instanceof ISingleElectron);
        assertEquals(se1, se);
        assertTrue(electronContainers.hasNext());
        se =  (ISingleElectron)electronContainers.next();
        assertTrue(se instanceof ISingleElectron);
        assertEquals(se2, se);
        
        assertFalse(electronContainers.hasNext());
    }
    
    public void testContains_IAtom() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);
        
        assertTrue(acetone.contains(c1));
        assertTrue(acetone.contains(c2));
        assertTrue(acetone.contains(o));
        assertTrue(acetone.contains(c3));
    }

    public void testAddLonePair_int() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);
        acetone.addLonePair(2);
        acetone.addLonePair(2);
        IBond b1 = builder.newBond(c1, c2,1);
        IBond b2 = builder.newBond(c1, o, 2);
        IBond b3 = builder.newBond(c1, c3,1);
        acetone.addBond(b1);
        acetone.addBond(b2);
        acetone.addBond(b3);
        
        assertEquals(3, acetone.getBondCount());
        assertEquals(5, acetone.getElectronContainerCount());
    }

    public void testGetMaximumBondOrder_IAtom() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);
        acetone.addLonePair(2);
        acetone.addLonePair(2);
        IBond b1 = builder.newBond(c1, c2,1);
        IBond b2 = builder.newBond(c1, o, 2);
        IBond b3 = builder.newBond(c1, c3,1);
        acetone.addBond(b1);
        acetone.addBond(b2);
        acetone.addBond(b3);
        
        assertEquals(2.0, acetone.getMaximumBondOrder(o) , 0.0001);
        assertEquals(2.0, acetone.getMaximumBondOrder(c1), 0.0001);
        assertEquals(1.0, acetone.getMaximumBondOrder(c2), 0.0001);
        assertEquals(1.0, acetone.getMaximumBondOrder(c3), 0.0001);
    }

    public void testGetMinimumBondOrder_IAtom() {
        // acetone molecule
        IMolecule acetone = builder.newMolecule();
        IAtom c1 = builder.newAtom("C");
        IAtom c2 = builder.newAtom("C");
        IAtom o = builder.newAtom("O");
        IAtom c3 = builder.newAtom("C");
        acetone.addAtom(c1);
        acetone.addAtom(c2);
        acetone.addAtom(c3);
        acetone.addAtom(o);
        acetone.addLonePair(2);
        acetone.addLonePair(2);
        IBond b1 = builder.newBond(c1, c2,1);
        IBond b2 = builder.newBond(c1, o, 2);
        IBond b3 = builder.newBond(c1, c3,1);
        acetone.addBond(b1);
        acetone.addBond(b2);
        acetone.addBond(b3);
        
        assertEquals(2.0, acetone.getMinimumBondOrder(o) , 0.0001);
        assertEquals(1.0, acetone.getMinimumBondOrder(c1), 0.0001);