testbinarytree.java

Office格式转换代码

        for (int k = 0; k < nodes.length; k++)
        {
            assertTrue(m.containsKey(nodes[ k ].getKey()));
            assertTrue(m.containsValue(nodes[ k ].getValue()));
        }
        m.clear();
        assertTrue(m.isEmpty());
        for (int k = 0; k < nodes.length; k++)
        {
            assertTrue(!m.containsKey(nodes[ k ].getKey()));
            assertTrue(!m.containsValue(nodes[ k ].getValue()));
        }
    }

    /**
     * test keySet() method
     */

    public void testKeySet()
    {
        testKeySet(new BinaryTree());
        Map           m       = new BinaryTree();
        LocalTestNode nodes[] = makeLocalNodes();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        testKeySet(m);
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        int count = m.size();

        for (Iterator iter = m.keySet().iterator(); iter.hasNext(); )
        {
            iter.next();
            iter.remove();
            --count;
            assertEquals(count, m.size());
        }
        assertTrue(m.isEmpty());
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        Set s = m.keySet();

        try
        {
            s.remove(null);
            fail("should have caught NullPointerException");
        }
        catch (NullPointerException ignored)
        {
        }
        try
        {
            s.remove(new Object());
            fail("should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }
        for (int k = 0; k < nodes.length; k++)
        {
            Comparable key = nodes[ k ].getKey();

            assertTrue(s.remove(key));
            assertTrue(!s.contains(key));
            assertTrue(!m.containsKey(key));
            assertTrue(!m.containsValue(nodes[ k ]));
        }
        assertTrue(m.isEmpty());
        m = new BinaryTree();
        Collection c1 = new LinkedList();
        Collection c2 = new LinkedList();

        c2.add(new Integer(-99));
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ].getKey());
            c2.add(nodes[ k ].getKey());
        }
        assertTrue(m.keySet().containsAll(c1));
        assertTrue(!m.keySet().containsAll(c2));
        m  = new BinaryTree();
        c1 = new LinkedList();
        c1.add(new Integer(-55));
        try
        {
            m.keySet().addAll(c1);
            fail("should have caught exception of addAll()");
        }
        catch (UnsupportedOperationException ignored)
        {
        }
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ].getKey());
        }
        assertTrue(!m.keySet().retainAll(c1));
        assertEquals(nodes.length, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            if (k % 2 == 1)
            {
                c1.add(nodes[ k ].getKey());
            }
        }
        assertTrue(m.keySet().retainAll(c1));
        assertEquals(nodes.length / 2, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(m.keySet().retainAll(c1));
        assertEquals(0, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(!m.keySet().removeAll(c1));
        assertEquals(nodes.length, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            if (k % 2 == 0)
            {
                c1.add(nodes[ k ].getKey());
            }
        }
        assertTrue(m.keySet().removeAll(c1));
        assertEquals(nodes.length / 2, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ].getKey());
        }
        assertTrue(m.keySet().removeAll(c1));
        assertTrue(m.size() == 0);
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        m.keySet().clear();
        assertTrue(m.size() == 0);
    }

    /**
     * test values() method
     */

    public void testValues()
    {
        testValues(new BinaryTree());
        Map           m       = new BinaryTree();
        LocalTestNode nodes[] = makeLocalNodes();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        testValues(m);
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        int count = m.size();

        for (Iterator iter = m.values().iterator(); iter.hasNext(); )
        {
            iter.next();
            iter.remove();
            --count;
            assertEquals(count, m.size());
        }
        assertTrue(m.isEmpty());
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        count = m.size();
        Collection s = m.values();

        for (int k = 0; k < count; k++)
        {
            assertTrue(s.remove(nodes[ k ]));
            assertTrue(!s.contains(nodes[ k ]));
            assertTrue(!m.containsKey(nodes[ k ].getKey()));
            assertTrue(!m.containsValue(nodes[ k ]));
        }
        assertTrue(m.isEmpty());
        m = new BinaryTree();
        Collection c1 = new LinkedList();
        Collection c2 = new LinkedList();

        c2.add(new LocalTestNode(-123));
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ]);
            c2.add(nodes[ k ]);
        }
        assertTrue(m.values().containsAll(c1));
        assertTrue(!m.values().containsAll(c2));
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ]);
        }
        try
        {
            m.values().addAll(c1);
            fail("should have caught exception of addAll()");
        }
        catch (UnsupportedOperationException ignored)
        {
        }
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ]);
        }
        assertTrue(!m.values().retainAll(c1));
        assertEquals(nodes.length, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            if (k % 2 == 1)
            {
                c1.add(nodes[ k ]);
            }
        }
        assertTrue(m.values().retainAll(c1));
        assertEquals(nodes.length / 2, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(m.values().retainAll(c1));
        assertEquals(0, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(!m.values().removeAll(c1));
        assertEquals(nodes.length, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            if (k % 2 == 0)
            {
                c1.add(nodes[ k ]);
            }
        }
        assertTrue(m.values().removeAll(c1));
        assertEquals(nodes.length / 2, m.size());
        m  = new BinaryTree();
        c1 = new LinkedList();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ]);
        }
        assertTrue(m.values().removeAll(c1));
        assertEquals(0, m.size());
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        m.values().clear();
        assertEquals(0, m.size());
    }

    /**
     * test entrySet() method
     */

    public void testEntrySet()
    {
        testEntrySet(new BinaryTree());
        Map           m       = new BinaryTree();
        LocalTestNode nodes[] = makeLocalNodes();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        testEntrySet(m);
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        try
        {
            (( Map.Entry ) m.entrySet().iterator().next())
                .setValue(new LocalTestNode(-1));
            fail("Should have caught UnsupportedOperationException");
        }
        catch (UnsupportedOperationException ignored)
        {
        }
        int count = m.size();

        for (Iterator iter = m.entrySet().iterator(); iter.hasNext(); )
        {
            iter.next();
            iter.remove();
            --count;
            assertEquals(count, m.size());
        }
        assertTrue(m.isEmpty());
        m = new BinaryTree();
        Collection c1 = new LinkedList();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            c1.add(nodes[ k ].getKey());
        }
        try
        {
            m.entrySet().addAll(c1);
            fail("should have caught exception of addAll()");
        }
        catch (UnsupportedOperationException ignored)
        {
        }
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        m.entrySet().clear();
        assertEquals(0, m.size());
        m = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        int x = 0;

        for (Iterator iter = m.entrySet().iterator(); iter.hasNext(); )
        {
            Map.Entry entry = ( Map.Entry ) iter.next();

            assertSame(entry.getKey(), nodes[ x ].getKey());
            assertSame(entry.getValue(), nodes[ x ]);
            x++;
        }
    }

    /**
     * Method testEquals
     */

    public void testEquals()
    {
        Map           m       = new BinaryTree();
        LocalTestNode nodes[] = makeLocalNodes();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(!m.equals(null));
        assertEquals(m, m);
        Map m1 = new HashMap();

        for (int k = 0; k < nodes.length; k++)
        {
            m1.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertEquals(m, m1);
        m1 = new BinaryTree();
        for (int k = 0; k < (nodes.length - 1); k++)
        {
            m1.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(!m.equals(m1));
        m1 = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m1.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        LocalTestNode node1 = new LocalTestNode(-1000);

        m1.put(node1.getKey(), node1);
        assertTrue(!m.equals(m1));
        m1 = new BinaryTree();
        for (int k = 0; k < nodes.length; k++)
        {
            m1.put(nodes[ k ].getKey(), nodes[ nodes.length - (k + 1) ]);
        }
        assertTrue(!m.equals(m1));
        m1 = new BinaryTree();
        for (int k = nodes.length - 1; k >= 0; k--)
        {
            m1.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertEquals(m, m1);
    }

    /**
     * test hashCode() method
     */

    public void testHashCode()
    {
        Map           m       = new BinaryTree();
        LocalTestNode nodes[] = makeLocalNodes();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        Map m1 = new BinaryTree();

        for (int k = nodes.length - 1; k >= 0; k--)
        {
            m1.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        assertTrue(m.hashCode() == m1.hashCode());
    }

    /**
     * test constructors
     */

    public void testConstructors()
    {
        BinaryTree m = new BinaryTree();

        assertTrue(m.isEmpty());
        BinaryTree m1 = new BinaryTree(m);

        assertTrue(m1.isEmpty());
        m1 = new BinaryTree();