testbinarytree.java

Office格式转换代码

        LocalTestNode nodes[] = makeLocalNodes();

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

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

        // reject duplicated values
        m2 = new HashMap();
        m2.put("1", "foo");
        m2.put("2", "foo");
        try
        {
            m = new BinaryTree(m2);
            fail("Should have caught IllegalArgumentException");
        }
        catch (IllegalArgumentException ignored)
        {
        }

        // reject null values
        m2.put("2", null);
        try
        {
            m = new BinaryTree(m2);
            fail("Should have caught NullPointerException");
        }
        catch (NullPointerException ignored)
        {
        }

        // reject non-Comparable values
        m2.put("2", new Object());
        try
        {
            m = new BinaryTree(m2);
            fail("Should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }

        // reject incompatible values
        m2.put("2", new Integer(2));
        try
        {
            m = new BinaryTree(m2);
            fail("Should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }

        // reject incompatible keys
        m2.remove("2");
        m2.put(new Integer(2), "bad key");
        try
        {
            m = new BinaryTree(m2);
            fail("Should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }

        // reject non-Comparable keys
        m2.clear();
        m2.put("1", "foo");
        m2.put(new Object(), "bad key");
        try
        {
            m = new BinaryTree(m2);
            fail("Should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }
    }

    /**
     * test getKeyForValue() method
     */

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

        try
        {
            m.getKeyForValue(new Object());
            fail("should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }
        try
        {
            m.getKeyForValue(null);
            fail("should have caught NullPointerException");
        }
        catch (NullPointerException ignored)
        {
        }
        assertNull(m.getKeyForValue("foo"));
        LocalTestNode nodes[] = makeLocalNodes();

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
            assertSame(m.getKeyForValue(nodes[ k ]), nodes[ k ].getKey());
        }
        assertNull(m.getKeyForValue(new LocalTestNode(-1)));
        try
        {
            m.getKeyForValue("foo");
            fail("Should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }
        for (int k = 0; k < nodes.length; k++)
        {
            assertNotNull(m.getKeyForValue(nodes[ k ]));
            m.remove(nodes[ k ].getKey());
            assertNull(m.getKeyForValue(nodes[ k ]));
        }
    }

    /**
     * test removeValue() method
     */

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

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        try
        {
            m.removeValue(null);
            fail("should have caught NullPointerException");
        }
        catch (NullPointerException ignored)
        {
        }
        try
        {
            m.removeValue(new Object());
            fail("should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }
        assertNull(m.remove(new Integer(-1)));
        try
        {
            m.removeValue("foo");
            fail("should have caught ClassCastException");
        }
        catch (ClassCastException ignored)
        {
        }
        for (int k = 0; k < nodes.length; k += 2)
        {
            assertNotNull(m.getKeyForValue(nodes[ k ]));
            assertSame(nodes[ k ].getKey(), m.removeValue(nodes[ k ]));
            assertNull(m.removeValue(nodes[ k ]));
            assertNull(m.getKeyForValue(nodes[ k ]));
        }
        for (int k = 1; k < nodes.length; k += 2)
        {
            assertNotNull(m.getKeyForValue(nodes[ k ]));
            assertSame(nodes[ k ].getKey(), m.removeValue(nodes[ k ]));
            assertNull(m.removeValue(nodes[ k ]));
            assertNull(m.getKeyForValue(nodes[ k ]));
        }
        assertTrue(m.isEmpty());
    }

    /**
     * test entrySetByValue() method
     */

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

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

        for (Iterator iter = m.entrySetByValue().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.entrySetByValue().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.entrySetByValue().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.entrySetByValue().iterator(); iter.hasNext(); )
        {
            Map.Entry entry = ( Map.Entry ) iter.next();

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

    /**
     * test keySetByValue() method
     */

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

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        testKeySetByValue(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.keySetByValue().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.keySetByValue();

        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.keySetByValue().containsAll(c1));
        assertTrue(!m.keySetByValue().containsAll(c2));
        m  = new BinaryTree();
        c1 = new LinkedList();
        c1.add(new Integer(-55));
        try
        {
            m.keySetByValue().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.keySetByValue().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.keySetByValue().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.keySetByValue().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.keySetByValue().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.keySetByValue().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.keySetByValue().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.keySetByValue().clear();
        assertTrue(m.size() == 0);
    }

    /**
     * test valuesByValue() method
     */

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

        for (int k = 0; k < nodes.length; k++)
        {
            m.put(nodes[ k ].getKey(), nodes[ k ]);
        }
        testValuesByValue(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.valuesByValue().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.valuesByValue();

        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();