| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.harmony.tests.java.util; |
| |
| import libcore.java.util.SpliteratorTester; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.SortedSet; |
| import java.util.Spliterator; |
| import java.util.TreeSet; |
| |
| public class TreeSetTest extends junit.framework.TestCase { |
| |
| public static class ReversedIntegerComparator implements Comparator { |
| public int compare(Object o1, Object o2) { |
| return -(((Integer) o1).compareTo((Integer) o2)); |
| } |
| |
| public boolean equals(Object o1, Object o2) { |
| return ((Integer) o1).compareTo((Integer) o2) == 0; |
| } |
| } |
| |
| TreeSet ts; |
| |
| Object objArray[] = new Object[1000]; |
| |
| /** |
| * java.util.TreeSet#TreeSet() |
| */ |
| public void test_Constructor() { |
| // Test for method java.util.TreeSet() |
| assertTrue("Did not construct correct TreeSet", new TreeSet().isEmpty()); |
| } |
| |
| /** |
| * java.util.TreeSet#TreeSet(java.util.Collection) |
| */ |
| public void test_ConstructorLjava_util_Collection() { |
| // Test for method java.util.TreeSet(java.util.Collection) |
| TreeSet myTreeSet = new TreeSet(Arrays.asList(objArray)); |
| assertTrue("TreeSet incorrect size", |
| myTreeSet.size() == objArray.length); |
| for (int counter = 0; counter < objArray.length; counter++) |
| assertTrue("TreeSet does not contain correct elements", myTreeSet |
| .contains(objArray[counter])); |
| } |
| |
| /** |
| * java.util.TreeSet#TreeSet(java.util.Comparator) |
| */ |
| public void test_ConstructorLjava_util_Comparator() { |
| // Test for method java.util.TreeSet(java.util.Comparator) |
| TreeSet myTreeSet = new TreeSet(new ReversedIntegerComparator()); |
| assertTrue("Did not construct correct TreeSet", myTreeSet.isEmpty()); |
| myTreeSet.add(new Integer(1)); |
| myTreeSet.add(new Integer(2)); |
| assertTrue( |
| "Answered incorrect first element--did not use custom comparator ", |
| myTreeSet.first().equals(new Integer(2))); |
| assertTrue( |
| "Answered incorrect last element--did not use custom comparator ", |
| myTreeSet.last().equals(new Integer(1))); |
| } |
| |
| /** |
| * java.util.TreeSet#TreeSet(java.util.SortedSet) |
| */ |
| public void test_ConstructorLjava_util_SortedSet() { |
| // Test for method java.util.TreeSet(java.util.SortedSet) |
| ReversedIntegerComparator comp = new ReversedIntegerComparator(); |
| TreeSet myTreeSet = new TreeSet(comp); |
| for (int i = 0; i < objArray.length; i++) |
| myTreeSet.add(objArray[i]); |
| TreeSet anotherTreeSet = new TreeSet(myTreeSet); |
| assertTrue("TreeSet is not correct size", |
| anotherTreeSet.size() == objArray.length); |
| for (int counter = 0; counter < objArray.length; counter++) |
| assertTrue("TreeSet does not contain correct elements", |
| anotherTreeSet.contains(objArray[counter])); |
| assertTrue("TreeSet does not answer correct comparator", anotherTreeSet |
| .comparator() == comp); |
| assertTrue("TreeSet does not use comparator", |
| anotherTreeSet.first() == objArray[objArray.length - 1]); |
| } |
| |
| /** |
| * java.util.TreeSet#add(java.lang.Object) |
| */ |
| public void test_addLjava_lang_Object() { |
| // Test for method boolean java.util.TreeSet.add(java.lang.Object) |
| ts.add(new Integer(-8)); |
| assertTrue("Failed to add Object", ts.contains(new Integer(-8))); |
| ts.add(objArray[0]); |
| assertTrue("Added existing element", ts.size() == objArray.length + 1); |
| |
| } |
| |
| /** |
| * java.util.TreeSet#addAll(java.util.Collection) |
| */ |
| public void test_addAllLjava_util_Collection() { |
| // Test for method boolean |
| // java.util.TreeSet.addAll(java.util.Collection) |
| TreeSet s = new TreeSet(); |
| s.addAll(ts); |
| assertTrue("Incorrect size after add", s.size() == ts.size()); |
| Iterator i = ts.iterator(); |
| while (i.hasNext()) |
| assertTrue("Returned incorrect set", s.contains(i.next())); |
| |
| } |
| |
| /** |
| * java.util.TreeSet#clear() |
| */ |
| public void test_clear() { |
| // Test for method void java.util.TreeSet.clear() |
| ts.clear(); |
| assertEquals("Returned non-zero size after clear", 0, ts.size()); |
| assertTrue("Found element in cleared set", !ts.contains(objArray[0])); |
| } |
| |
| /** |
| * java.util.TreeSet#clone() |
| */ |
| public void test_clone() { |
| // Test for method java.lang.Object java.util.TreeSet.clone() |
| TreeSet s = (TreeSet) ts.clone(); |
| Iterator i = ts.iterator(); |
| while (i.hasNext()) |
| assertTrue("Clone failed to copy all elements", s |
| .contains(i.next())); |
| } |
| |
| /** |
| * java.util.TreeSet#comparator() |
| */ |
| public void test_comparator() { |
| // Test for method java.util.Comparator java.util.TreeSet.comparator() |
| ReversedIntegerComparator comp = new ReversedIntegerComparator(); |
| TreeSet myTreeSet = new TreeSet(comp); |
| assertTrue("Answered incorrect comparator", |
| myTreeSet.comparator() == comp); |
| } |
| |
| /** |
| * java.util.TreeSet#contains(java.lang.Object) |
| */ |
| public void test_containsLjava_lang_Object() { |
| // Test for method boolean java.util.TreeSet.contains(java.lang.Object) |
| assertTrue("Returned false for valid Object", ts |
| .contains(objArray[objArray.length / 2])); |
| assertTrue("Returned true for invalid Object", !ts |
| .contains(new Integer(-9))); |
| try { |
| ts.contains(new Object()); |
| } catch (ClassCastException e) { |
| // Correct |
| return; |
| } |
| fail("Failed to throw exception when passed invalid element"); |
| |
| } |
| |
| /** |
| * java.util.TreeSet#first() |
| */ |
| public void test_first() { |
| // Test for method java.lang.Object java.util.TreeSet.first() |
| assertTrue("Returned incorrect first element", |
| ts.first() == objArray[0]); |
| } |
| |
| /** |
| * java.util.TreeSet#headSet(java.lang.Object) |
| */ |
| public void test_headSetLjava_lang_Object() { |
| // Test for method java.util.SortedSet |
| // java.util.TreeSet.headSet(java.lang.Object) |
| Set s = ts.headSet(new Integer(100)); |
| assertEquals("Returned set of incorrect size", 100, s.size()); |
| for (int i = 0; i < 100; i++) |
| assertTrue("Returned incorrect set", s.contains(objArray[i])); |
| } |
| |
| /** |
| * java.util.TreeSet#isEmpty() |
| */ |
| public void test_isEmpty() { |
| // Test for method boolean java.util.TreeSet.isEmpty() |
| assertTrue("Empty set returned false", new TreeSet().isEmpty()); |
| assertTrue("Non-Empty returned true", !ts.isEmpty()); |
| } |
| |
| /** |
| * java.util.TreeSet#iterator() |
| */ |
| public void test_iterator() { |
| // Test for method java.util.Iterator java.util.TreeSet.iterator() |
| TreeSet s = new TreeSet(); |
| s.addAll(ts); |
| Iterator i = ts.iterator(); |
| Set as = new HashSet(Arrays.asList(objArray)); |
| while (i.hasNext()) |
| as.remove(i.next()); |
| assertEquals("Returned incorrect iterator", 0, as.size()); |
| |
| } |
| |
| /** |
| * java.util.TreeSet#last() |
| */ |
| public void test_last() { |
| // Test for method java.lang.Object java.util.TreeSet.last() |
| assertTrue("Returned incorrect last element", |
| ts.last() == objArray[objArray.length - 1]); |
| } |
| |
| /** |
| * java.util.TreeSet#remove(java.lang.Object) |
| */ |
| public void test_removeLjava_lang_Object() { |
| // Test for method boolean java.util.TreeSet.remove(java.lang.Object) |
| ts.remove(objArray[0]); |
| assertTrue("Failed to remove object", !ts.contains(objArray[0])); |
| assertTrue("Failed to change size after remove", |
| ts.size() == objArray.length - 1); |
| try { |
| ts.remove(new Object()); |
| } catch (ClassCastException e) { |
| // Correct |
| return; |
| } |
| fail("Failed to throw exception when past uncomparable value"); |
| } |
| |
| /** |
| * java.util.TreeSet#size() |
| */ |
| public void test_size() { |
| // Test for method int java.util.TreeSet.size() |
| assertTrue("Returned incorrect size", ts.size() == objArray.length); |
| } |
| |
| /** |
| * java.util.TreeSet#subSet(java.lang.Object, java.lang.Object) |
| */ |
| public void test_subSetLjava_lang_ObjectLjava_lang_Object() { |
| // Test for method java.util.SortedSet |
| // java.util.TreeSet.subSet(java.lang.Object, java.lang.Object) |
| final int startPos = objArray.length / 4; |
| final int endPos = 3 * objArray.length / 4; |
| SortedSet aSubSet = ts.subSet(objArray[startPos], objArray[endPos]); |
| assertTrue("Subset has wrong number of elements", |
| aSubSet.size() == (endPos - startPos)); |
| for (int counter = startPos; counter < endPos; counter++) |
| assertTrue("Subset does not contain all the elements it should", |
| aSubSet.contains(objArray[counter])); |
| |
| int result; |
| try { |
| ts.subSet(objArray[3], objArray[0]); |
| result = 0; |
| } catch (IllegalArgumentException e) { |
| result = 1; |
| } |
| assertEquals("end less than start should throw", 1, result); |
| } |
| |
| /** |
| * java.util.TreeSet#tailSet(java.lang.Object) |
| */ |
| public void test_tailSetLjava_lang_Object() { |
| // Test for method java.util.SortedSet |
| // java.util.TreeSet.tailSet(java.lang.Object) |
| Set s = ts.tailSet(new Integer(900)); |
| assertEquals("Returned set of incorrect size", 100, s.size()); |
| for (int i = 900; i < objArray.length; i++) |
| assertTrue("Returned incorrect set", s.contains(objArray[i])); |
| } |
| |
| /** |
| * Tests equals() method. |
| * Tests that no ClassCastException will be thrown in all cases. |
| * Regression test for HARMONY-1639. |
| */ |
| public void test_equals() throws Exception { |
| // comparing TreeSets with different object types |
| Set s1 = new TreeSet(); |
| Set s2 = new TreeSet(); |
| s1.add("key1"); |
| s1.add("key2"); |
| s2.add(new Integer(1)); |
| s2.add(new Integer(2)); |
| assertFalse("Sets should not be equal 1", s1.equals(s2)); |
| assertFalse("Sets should not be equal 2", s2.equals(s1)); |
| |
| // comparing TreeSet with HashSet |
| s1 = new TreeSet(); |
| s2 = new HashSet(); |
| s1.add("key"); |
| s2.add(new Object()); |
| assertFalse("Sets should not be equal 3", s1.equals(s2)); |
| assertFalse("Sets should not be equal 4", s2.equals(s1)); |
| } |
| |
| public void test_spliterator() throws Exception { |
| TreeSet<String> treeSet = new TreeSet<>(); |
| List<String> keys = Arrays.asList( |
| "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"); |
| treeSet.addAll(keys); |
| |
| ArrayList<String> expectedKeys = new ArrayList<>(keys); |
| SpliteratorTester.runBasicIterationTests_unordered(treeSet.spliterator(), expectedKeys, |
| String::compareTo); |
| SpliteratorTester.runBasicSplitTests(treeSet, expectedKeys); |
| SpliteratorTester.testSpliteratorNPE(treeSet.spliterator()); |
| |
| assertTrue(treeSet.spliterator().hasCharacteristics(Spliterator.ORDERED)); |
| SpliteratorTester.runOrderedTests(keys); |
| |
| assertTrue(treeSet.spliterator().hasCharacteristics(Spliterator.DISTINCT)); |
| SpliteratorTester.runDistinctTests(keys); |
| } |
| |
| /** |
| * Sets up the fixture, for example, open a network connection. This method |
| * is called before a test is executed. |
| */ |
| protected void setUp() { |
| ts = new TreeSet(); |
| for (int i = 0; i < objArray.length; i++) { |
| Object x = objArray[i] = new Integer(i); |
| ts.add(x); |
| } |
| } |
| |
| /** |
| * Tears down the fixture, for example, close a network connection. This |
| * method is called after a test is executed. |
| */ |
| protected void tearDown() { |
| } |
| } |