/** * Check that the set is consistent, i.e all allocated slots are reachable by get(), and all * not-allocated contains nulls if Generic * * @param set */ @After public void checkConsistency() { if (this.set != null) { int occupied = 0; final int mask = getKeys(this.set).length - 1; for (int i = 0; i < getKeys(this.set).length; i++) { if (!is_allocated(i, Intrinsics.<KType[]>cast(getKeys(this.set)))) { // if not allocated, generic version if patched to null for GC sake /*! #if ($TemplateOptions.KTypeGeneric) !*/ TestUtils.assertEquals2(this.keyE, getKeys(this.set)[i]); /*! #end !*/ } else { // try to reach the key by contains() Assert.assertTrue(this.set.contains(Intrinsics.<KType>cast(getKeys(this.set)[i]))); occupied++; } } if (isAllocatedDefaultKey(this.set)) { // try to reach the key by contains() Assert.assertTrue(this.set.contains(this.keyE)); occupied++; } Assert.assertEquals(occupied, this.set.size()); } }
@Test public void testIterable2() { addFromArray(this.set, this.keyE, this.key1, this.key2, this.key2, this.key3, this.key4); this.set.remove(this.k2); Assert.assertEquals(4, this.set.size()); int counted = 0; for (final KTypeCursor<KType> cursor : this.set) { if (cursor.index == getKeys(this.set).length) { Assert.assertTrue(this.isAllocatedDefaultKey(this.set)); TestUtils.assertEquals2(this.keyE, cursor.value); counted++; continue; } Assert.assertTrue(this.set.contains(cursor.value)); TestUtils.assertEquals2(cursor.value, this.getKeys(this.set)[cursor.index]); counted++; } Assert.assertEquals(counted, this.set.size()); this.set.clear(); Assert.assertFalse(this.set.iterator().hasNext()); }
/** * Run some random insertions/ deletions and compare the results against <code>java.util.HashSet * </code>. */ @Test public void testAgainstHashMap() { final java.util.Random rnd = new Random(0xBADCAFE); final java.util.HashSet<KType> other = new java.util.HashSet<KType>(); for (int size = 1000; size < 20000; size += 4000) { other.clear(); this.set.clear(); for (int round = 0; round < size * 20; round++) { final KType key = cast(rnd.nextInt(size)); if (rnd.nextBoolean()) { other.add(key); this.set.add(key); Assert.assertTrue(this.set.contains(key)); } else { Assert.assertTrue( "size= " + size + ", round = " + round, other.remove(key) == this.set.remove(key)); } Assert.assertEquals(other.size(), this.set.size()); } } }
@Test public void testNullKey() { this.set.add((KType) null); Assert.assertEquals(1, this.set.size()); Assert.assertTrue(this.set.contains(null)); Assert.assertTrue(this.set.remove(null)); Assert.assertEquals(0, this.set.size()); Assert.assertFalse(this.set.contains(null)); }
/*! #if ($TemplateOptions.KTypeGeneric) !*/ @SuppressWarnings("unchecked") @Test public void testHashCodeWithNulls() { final KTypeSet<KType> l1 = getFrom(this.k1, null, this.k3); final KTypeSet<KType> l2 = getFrom(this.k1, null); l2.add(this.k3); Assert.assertEquals(l1.hashCode(), l2.hashCode()); Assert.assertEquals(l1, l2); }
@Test public void testClear() { addFromArray(this.set, asArray(1, 2, 3)); this.set.clear(); checkConsistency(); Assert.assertEquals(0, this.set.size()); addFromArray(this.set, asArray(0, 2, 8)); this.set.clear(); checkConsistency(); Assert.assertEquals(0, this.set.size()); }
@Test public void testRemove() { Assert.assertFalse(this.set.remove(this.k2)); Assert.assertFalse(this.set.remove(this.keyE)); addFromArray(this.set, this.key0, this.key1, this.key2, this.key3, this.key4); Assert.assertTrue(this.set.remove(this.k2)); Assert.assertFalse(this.set.remove(this.k2)); Assert.assertEquals(4, this.set.size()); TestUtils.assertSortedListEquals(this.set.toArray(), 0, 1, 3, 4); }
@Test public void testAddAll() { final KTypeSet<KType> set2 = createNewSetInstance(); addFromArray(set2, asArray(1, 2)); addFromArray(this.set, asArray(0, 1)); Assert.assertEquals(1, this.set.addAll(set2)); Assert.assertEquals(0, this.set.addAll(set2)); Assert.assertEquals(3, this.set.size()); TestUtils.assertSortedListEquals(this.set.toArray(), 0, 1, 2); }
@Test public void testRemoveAllFromLookupContainer() { addFromArray(this.set, asArray(0, 1, 2, 3, 4)); // test against concrete HashSet final KTypeHashSet<KType> set2 = new KTypeHashSet<KType>(); set2.add(asArray(1, 3, 5)); Assert.assertEquals(2, this.set.removeAll(set2)); Assert.assertEquals(3, this.set.size()); TestUtils.assertSortedListEquals(this.set.toArray(), 0, 2, 4); }
@Test public void testPooledIteratorFullIteratorLoop() { // A) for-each loop interrupted // must accommodate even the smallest primitive type // so that the iteration do not break before it should... final int TEST_SIZE = 126; final long TEST_ROUNDS = 5000; final KTypeSet<KType> testContainer = createSetWithOrderedData(TEST_SIZE); final long checksum = testContainer.forEach( new KTypeProcedure<KType>() { long count; @Override public void apply(final KType value) { this.count += castType(value); } }) .count; long testValue = 0; final int startingPoolSize = getEntryPoolSize(testContainer); for (int round = 0; round < TEST_ROUNDS; round++) { // Classical iterator loop, with manually allocated Iterator final int initialPoolSize = getEntryPoolSize(testContainer); final AbstractIterator<KTypeCursor<KType>> loopIterator = (AbstractIterator<KTypeCursor<KType>>) testContainer.iterator(); Assert.assertEquals(initialPoolSize - 1, getEntryPoolSize(testContainer)); testValue = 0; while (loopIterator.hasNext()) { testValue += castType(loopIterator.next().value); } // end IteratorLoop // iterator is returned automatically to its pool, by normal iteration termination Assert.assertEquals(initialPoolSize, getEntryPoolSize(testContainer)); // checksum Assert.assertEquals(checksum, testValue); } // end for rounds // pool initial size is untouched anyway Assert.assertEquals(startingPoolSize, getEntryPoolSize(testContainer)); }
@Repeat(iterations = 10) @Test public void testPreallocatedSize() { final Random randomVK = RandomizedTest.getRandom(); // Test that the container do not resize if less that the initial size // 1) Choose a random number of elements /*! #if ($TemplateOptions.isKType("GENERIC", "INT", "LONG", "FLOAT", "DOUBLE")) !*/ final int PREALLOCATED_SIZE = randomVK.nextInt(10000); /*! #elseif ($TemplateOptions.isKType("SHORT", "CHAR")) int PREALLOCATED_SIZE = randomVK.nextInt(1500); #else int PREALLOCATED_SIZE = randomVK.nextInt(126); #end !*/ final KTypeSet<KType> newSet = createNewSetInstance(PREALLOCATED_SIZE, HashContainers.DEFAULT_LOAD_FACTOR); // computed real capacity final int realCapacity = newSet.capacity(); // 3) Add PREALLOCATED_SIZE different values. At the end, size() must be == realCapacity, // and internal buffer/allocated must not have changed of size final int contructorBufferSize = getKeys(newSet).length; Assert.assertEquals(contructorBufferSize, getKeys(newSet).length); for (int i = 0; i < 1.5 * realCapacity; i++) { newSet.add(cast(i)); // internal size has not changed until realCapacity if (newSet.size() <= realCapacity) { Assert.assertEquals(contructorBufferSize, getKeys(newSet).length); } if (contructorBufferSize < getKeys(newSet).length) { // The container as just reallocated, its actual size must be not too far from the previous // capacity: Assert.assertTrue( "Container as reallocated at size = " + newSet.size() + " with previous capacity = " + realCapacity, (newSet.size() - realCapacity) <= 3); break; } } }
@Test public void testPooledIteratorBrokenIteratorLoop() { // A) for-each loop interrupted // must accommodate even the smallest primitive type // so that the iteration do not break before it should... final int TEST_SIZE = 126; final long TEST_ROUNDS = 5000; final KTypeSet<KType> testContainer = createSetWithOrderedData(TEST_SIZE); final int startingPoolSize = getEntryPoolSize(testContainer); int count = 0; for (int round = 0; round < TEST_ROUNDS; round++) { // Classical iterator loop, with manually allocated Iterator final long initialPoolSize = getEntryPoolSize(testContainer); final AbstractIterator<KTypeCursor<KType>> loopIterator = (AbstractIterator<KTypeCursor<KType>>) testContainer.iterator(); Assert.assertEquals(initialPoolSize - 1, getEntryPoolSize(testContainer)); count = 0; int guard = 0; while (loopIterator.hasNext()) { guard += castType(loopIterator.next().value); // brutally interrupt in the middle if (count > TEST_SIZE / 2) { break; } count++; } // end IteratorLoop // iterator is NOT returned to its pool, due to the break. Assert.assertEquals(initialPoolSize - 1, getEntryPoolSize(testContainer)); // manual return to the pool loopIterator.release(); // now the pool is restored Assert.assertEquals(initialPoolSize, getEntryPoolSize(testContainer)); } // end for rounds // pool initial size is untouched anyway Assert.assertEquals(startingPoolSize, getEntryPoolSize(testContainer)); }
@Test public void testForEachProcedure() { // Test that the container do not resize if less that the initial size // 1) Choose a map to build /*! #if ($TemplateOptions.isKType("GENERIC", "int", "long", "float", "double")) !*/ final int NB_ELEMENTS = 2000; /*! #elseif ($TemplateOptions.isKType("short", "char")) int NB_ELEMENTS = 1000; #else int NB_ELEMENTS = 126; #end !*/ final KTypeSet<KType> newSet = createNewSetInstance(); newSet.add(this.keyE); // add a increasing number of key for (int i = 0; i < NB_ELEMENTS; i++) { final int KVpair = i; newSet.add(cast(KVpair)); } // List the keys in the reverse-order of the internal buffer, since forEach() is iterating in // reverse also: final KTypeArrayList<KType> keyList = new KTypeArrayList<KType>(); keyList.add(this.keyE); for (int i = getKeys(newSet).length - 1; i >= 0; i--) { if (is_allocated(i, Intrinsics.<KType[]>cast(getKeys(newSet)))) { keyList.add(Intrinsics.<KType>cast(getKeys(newSet)[i])); } } // Test forEach predicate and stop at each key in turn. final KTypeArrayList<KType> keyListTest = new KTypeArrayList<KType>(); keyListTest.clear(); // A) Run forEach(KType) newSet.forEach( new KTypeProcedure<KType>() { @Override public void apply(final KType key) { keyListTest.add(key); } }); // check that keyList/keyListTest and valueList/valueListTest are identical. Assert.assertEquals(keyList, keyListTest); }
@Test public void testPooledIteratorForEach() { // A) Unbroken for-each loop // must accommodate even the smallest primitive type // so that the iteration do not break before it should... final int TEST_SIZE = 126; final long TEST_ROUNDS = 5000; final KTypeSet<KType> testContainer = createSetWithOrderedData(TEST_SIZE); final long checksum = testContainer.forEach( new KTypeProcedure<KType>() { long count; @Override public void apply(final KType value) { this.count += castType(value); } }) .count; long testValue = 0; final long initialPoolSize = getEntryPoolSize(testContainer); for (int round = 0; round < TEST_ROUNDS; round++) { // for-each in test : testValue = 0; for (final KTypeCursor<KType> cursor : testContainer) { // we consume 1 iterator for this loop Assert.assertEquals(initialPoolSize - 1, getEntryPoolSize(testContainer)); testValue += castType(cursor.value); } // check checksum the iteration Assert.assertEquals(checksum, testValue); // iterator is returned to its pool Assert.assertEquals(initialPoolSize, getEntryPoolSize(testContainer)); } // end for rounds }
@Test public void testAdd() { Assert.assertTrue(this.set.add(this.key1)); Assert.assertFalse(this.set.add(this.key1)); Assert.assertEquals(1, this.set.size()); Assert.assertTrue(this.set.add(this.keyE)); Assert.assertFalse(this.set.add(this.keyE)); Assert.assertEquals(2, this.set.size()); Assert.assertTrue(this.set.add(this.key2)); Assert.assertFalse(this.set.add(this.key2)); Assert.assertEquals(3, this.set.size()); }
@Test public void testPooledIteratorBrokenForEach() { // A) for-each loop interrupted // must accommodate even the smallest primitive type // so that the iteration do not break before it should... final int TEST_SIZE = 126; final long TEST_ROUNDS = 5000; final KTypeSet<KType> testContainer = createSetWithOrderedData(TEST_SIZE); int count = 0; for (int round = 0; round < TEST_ROUNDS; round++) { // for-each in test : final long initialPoolSize = getEntryPoolSize(testContainer); count = 0; int guard = 0; for (final KTypeCursor<KType> cursor : testContainer) { guard += castType(cursor.value); // we consume 1 iterator for this loop, but reallocs can happen, // so we can only say its != initialPoolSize Assert.assertTrue(initialPoolSize != getEntryPoolSize(testContainer)); // brutally interrupt in the middle if (count > TEST_SIZE / 2) { break; } count++; } // end for-each // iterator is NOT returned to its pool, due to the break. // reallocation could happen, so that the only testable thing // is that the size is != full pool Assert.assertTrue(initialPoolSize != getEntryPoolSize(testContainer)); } // end for rounds // Due to policy of the Iterator pool, the intended pool never get bigger that some limit // despite the Iterator leak. Assert.assertTrue(getEntryPoolCapacity(testContainer) < IteratorPool.getMaxPoolSize() + 1); }
@Test public void testInitialCapacityAndGrowth() { for (int i = 0; i < 256; i++) { final KTypeSet<KType> set = createNewSetInstance(i, HashContainers.MAX_LOAD_FACTOR); for (int j = 0; j < i; j++) { set.add(cast(j)); } Assert.assertEquals(i, set.size()); } }
@Test public void testRemoveAllWithPredicateInterrupted() { addFromArray( this.set, newArray(this.k0, this.k1, this.k2, this.k3, this.k4, this.k5, this.k6, this.k7, this.k8)); final RuntimeException t = new RuntimeException(); try { // the assert below should never be triggered because of the exception // so give it an invalid value in case the thing terminates = initial size + 1 Assert.assertEquals( 10, this.set.removeAll( new KTypePredicate<KType>() { @Override public boolean apply(final KType v) { if (v == AbstractKTypeHashSetTest.this.key7) { throw t; } return v == AbstractKTypeHashSetTest.this.key2 || v == AbstractKTypeHashSetTest.this.key9 || v == AbstractKTypeHashSetTest.this.key5; }; })); Assert.fail(); } catch (final RuntimeException e) { // Make sure it's really our exception... if (e != t) { throw e; } } // And check if the set is in consistent state. We cannot predict the pattern, // but we know that since key7 throws an exception, key7 is still present in the set. Assert.assertTrue(this.set.contains(this.key7)); checkConsistency(); }
@Test public void testRemoveAllWithPredicate() { addFromArray(this.set, newArray(this.k0, this.k1, this.k2)); Assert.assertEquals( 1, this.set.removeAll( new KTypePredicate<KType>() { @Override public boolean apply(final KType v) { return v == AbstractKTypeHashSetTest.this.k1; }; })); TestUtils.assertSortedListEquals(this.set.toArray(), this.k0, this.k2); }
/*! #if ($TemplateOptions.isKType("int", "short", "byte", "long", "Object")) !*/ @Test public void testToString() { Assume.assumeTrue( int[].class.isInstance(getKeys(this.set)) || short[].class.isInstance(getKeys(this.set)) || byte[].class.isInstance(getKeys(this.set)) || long[].class.isInstance(getKeys(this.set)) || Object[].class.isInstance(getKeys(this.set))); addFromArray(this.set, this.key1, this.key2); String asString = this.set.toString(); asString = asString.replaceAll("[\\[\\],\\ ]", ""); final char[] asCharArray = asString.toCharArray(); Arrays.sort(asCharArray); Assert.assertEquals("12", new String(asCharArray)); }
@Test public void testRemoveAllWithPredicate2() { addFromArray(this.set, this.keyE, this.key1, this.key2, this.key4); Assert.assertEquals( 2, this.set.removeAll( new KTypePredicate<KType>() { @Override public boolean apply(final KType v) { return (v == AbstractKTypeHashSetTest.this.key1) || (v == AbstractKTypeHashSetTest.this.keyE); }; })); TestUtils.assertSortedListEquals(this.set.toArray(), this.key2, this.key4); }
@Test public void testRetainAllWithPredicate2() { addFromArray(this.set, newArray(this.keyE, this.k1, this.k2, this.k3, this.k4, this.k5)); Assert.assertEquals( 4, this.set.retainAll( new KTypePredicate<KType>() { @Override public boolean apply(final KType v) { return v == AbstractKTypeHashSetTest.this.keyE || v == AbstractKTypeHashSetTest.this.k3; }; })); TestUtils.assertSortedListEquals(this.set.toArray(), this.keyE, this.k3); }
@Test /*! #if ($TemplateOptions.KTypeGeneric) !*/ @SuppressWarnings("unchecked") /*! #end !*/ public void testHashCodeEquals() { final KTypeSet<KType> l0 = getFrom(); Assert.assertEquals(0, l0.hashCode()); Assert.assertEquals(l0, createNewSetInstance()); final KTypeSet<KType> l1 = getFrom(this.k1, this.k2, this.k3); final KTypeSet<KType> l2 = getFrom(this.k1, this.k2); l2.add(this.k3); Assert.assertEquals(l1.hashCode(), l2.hashCode()); Assert.assertEquals(l1, l2); l1.add(this.keyE); l2.add(this.keyE); Assert.assertEquals(l1.hashCode(), l2.hashCode()); Assert.assertEquals(l1, l2); }
@Test public void testInitiallyEmpty() { Assert.assertEquals(0, this.set.size()); }
@Test public void testForEachProcedureWithException() { // Test that the container do not resize if less that the initial size // 1) Choose a map to build /*! #if ($TemplateOptions.isKType("GENERIC", "int", "long", "float", "double")) !*/ final int NB_ELEMENTS = 2000; /*! #elseif ($TemplateOptions.isKType("short", "char")) int NB_ELEMENTS = 1000; #else int NB_ELEMENTS = 126; #end !*/ final KTypeSet<KType> newSet = createNewSetInstance(); newSet.add(this.keyE); // add a increasing number of key for (int i = 0; i < NB_ELEMENTS; i++) { final int KVpair = i; newSet.add(cast(KVpair)); } // List the keys in the reverse-order of the internal buffer, since forEach() is iterating in // reverse also: final KTypeArrayList<KType> keyList = new KTypeArrayList<KType>(); keyList.add(this.keyE); // Test forEach predicate and stop at each key in turn. final KTypeArrayList<KType> keyListTest = new KTypeArrayList<KType>(); for (int k = getKeys(newSet).length - 1; k >= 0; k--) { if (is_allocated(k, Intrinsics.<KType[]>cast(getKeys(newSet)))) { keyList.add(Intrinsics.<KType>cast(getKeys(newSet)[k])); } } final int size = keyList.size(); for (int i = 0; i < size; i++) { final int currentPairIndexSizeToIterate = i + 1; keyListTest.clear(); keyList.clear(); keyList.add(this.keyE); for (int k = getKeys(newSet).length - 1; k >= 0; k--) { if (is_allocated(k, Intrinsics.<KType[]>cast(getKeys(newSet)))) { keyList.add(Intrinsics.<KType>cast(getKeys(newSet)[k])); } } // A) Run forEach(KType) try { newSet.forEach( new KTypeProcedure<KType>() { @Override public void apply(final KType key) { keyListTest.add(key); // when the stopping key/value pair is encountered, add to list and stop iteration if (key == keyList.get(currentPairIndexSizeToIterate - 1)) { // interrupt iteration by an exception throw new RuntimeException("Interrupted treatment by test"); } } }); } catch (final RuntimeException e) { if (!e.getMessage().equals("Interrupted treatment by test")) { throw e; } } finally { // despite the exception, the procedure terminates cleanly // check that keyList/keyListTest and valueList/valueListTest are identical for the first // currentPairIndexToIterate + 1 elements Assert.assertEquals("i = " + i, currentPairIndexSizeToIterate, keyListTest.size()); for (int j = 0; j < currentPairIndexSizeToIterate; j++) { TestUtils.assertEquals2("j = " + j, keyList.get(j), keyListTest.get(j)); } } // end finally } // end for each index }
@Test public void testPooledIteratorExceptionIteratorLoop() { // must accommodate even the smallest primitive type // so that the iteration do not break before it should... final int TEST_SIZE = 126; final long TEST_ROUNDS = 5000; final KTypeSet<KType> testContainer = createSetWithOrderedData(TEST_SIZE); final long checksum = testContainer.forEach( new KTypeProcedure<KType>() { long count; @Override public void apply(final KType value) { this.count += castType(value); } }) .count; final int startingPoolSize = getEntryPoolSize(testContainer); int count = 0; AbstractIterator<KTypeCursor<KType>> loopIterator = null; for (int round = 0; round < TEST_ROUNDS; round++) { try { loopIterator = (AbstractIterator<KTypeCursor<KType>>) testContainer.iterator(); Assert.assertEquals(startingPoolSize - 1, getEntryPoolSize(testContainer)); int guard = 0; count = 0; while (loopIterator.hasNext()) { guard += castType(loopIterator.next().value); // brutally interrupt in the middle some of the loops, but not all if (round > TEST_ROUNDS / 2 && count > TEST_SIZE / 2) { throw new Exception("Oups some problem in the loop occured"); } count++; } // end while // iterator is returned to its pool in case of normal loop termination Assert.assertEquals(startingPoolSize, getEntryPoolSize(testContainer)); Assert.assertEquals(checksum, guard); } catch (final Exception e) { // iterator is NOT returned to its pool because of the exception Assert.assertEquals(startingPoolSize - 1, getEntryPoolSize(testContainer)); // manual return to the pool then loopIterator.release(); // now the pool is restored Assert.assertEquals(startingPoolSize, getEntryPoolSize(testContainer)); } } // end for rounds // pool initial size is untouched anyway Assert.assertEquals(startingPoolSize, getEntryPoolSize(testContainer)); }
@Test /*! #if ($TemplateOptions.KTypeGeneric) !*/ @SuppressWarnings("unchecked") /*! #end !*/ public void testEquals() { final KTypeSet<KType> l0 = getFrom(); Assert.assertEquals(l0, createNewSetInstance()); KTypeSet<KType> l1 = getFrom(this.k1, this.k2, this.k3, this.k4, this.k5); KTypeSet<KType> l2 = getFrom(this.k2, this.k1); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); Assert.assertFalse(l1.equals(null)); Assert.assertFalse(l2.equals(null)); l2.add(this.k5); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l2.add(this.k4); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l2.add(this.k3); Assert.assertEquals(l1, l2); Assert.assertEquals(l2, l1); // Check consistency with hashCode: Assert.assertEquals(l1.hashCode(), l2.hashCode()); l1.add(this.keyE); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l2.add(this.keyE); Assert.assertEquals(l1, l2); Assert.assertEquals(l2, l1); // Check consistency with hashCode: Assert.assertEquals(l1.hashCode(), l2.hashCode()); l2.remove(this.keyE); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l2.add(this.keyE); Assert.assertEquals(l1, l2); Assert.assertEquals(l2, l1); // Check consistency with hashCode: Assert.assertEquals(l1.hashCode(), l2.hashCode()); l2.remove(this.k7); // not present, sets are still OK Assert.assertEquals(l1, l2); Assert.assertEquals(l2, l1); // Check consistency with hashCode: Assert.assertEquals(l1.hashCode(), l2.hashCode()); l2.remove(this.k2); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l1.remove(this.k2); Assert.assertEquals(l1, l2); Assert.assertEquals(l2, l1); // Check consistency with hashCode: Assert.assertEquals(l1.hashCode(), l2.hashCode()); l1.add(this.k7); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l2.clear(); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); l1.clear(); Assert.assertEquals(l1, l2); Assert.assertEquals(l2, l1); // Check consistency with hashCode: Assert.assertEquals(l1.hashCode(), l2.hashCode()); // Same size, different contents l1 = getFrom(this.k1, this.k2, this.k3, this.k4, this.k5); l2 = getFrom(this.k2, this.k1, this.key5, this.key6, this.key7); Assert.assertNotEquals(l1, l2); Assert.assertNotEquals(l2, l1); }
@Repeat(iterations = 25) @Seed("88DC7A1093FD66C5") @Test public void testNoOverallocation() { final Random randomVK = RandomizedTest.getRandom(); // Test that the container do not resize if less that the initial size // 1) Choose a random number of elements /*! #if ($TemplateOptions.isKType("GENERIC", "INT", "LONG", "FLOAT", "DOUBLE")) !*/ final int PREALLOCATED_SIZE = randomVK.nextInt(10000); /*! #elseif ($TemplateOptions.isKType("SHORT", "CHAR")) int PREALLOCATED_SIZE = randomVK.nextInt(126); #else int PREALLOCATED_SIZE = randomVK.nextInt(10000); #end !*/ // 2) Preallocate to PREALLOCATED_SIZE, use default factor because copy-constructor use this. final KTypeSet<KType> refContainer = createNewSetInstance(PREALLOCATED_SIZE, HashContainers.DEFAULT_LOAD_FACTOR); final int refCapacity = refContainer.capacity(); // 3) Fill with random values, random number of elements below preallocation final int nbElements = RandomizedTest.randomInt(PREALLOCATED_SIZE); for (int i = 0; i < nbElements; i++) { refContainer.add(cast(i)); } // Capacity must have not changed, i.e no reallocation must have occured. Assert.assertEquals(refCapacity, refContainer.capacity()); final int nbRefElements = refContainer.size(); Assert.assertEquals(refCapacity, refContainer.capacity()); // 4) Duplicate by copy-construction and/or clone KTypeSet<KType> clonedContainer = getClone(refContainer); KTypeSet<KType> copiedContainer = getCopyConstructor(refContainer); final int copiedCapacity = copiedContainer.capacity(); final int clonedCapacity = copiedContainer.capacity(); Assert.assertEquals(nbRefElements, clonedContainer.size()); Assert.assertEquals(nbRefElements, copiedContainer.size()); // Due to different pre-sizings, clones and copy constructed may or may not have the same // capacity as the refContainer. Assert.assertTrue(clonedContainer.equals(refContainer)); Assert.assertTrue(copiedContainer.equals(refContainer)); // Maybe we were lucky, iterate duplication over itself several times for (int j = 0; j < 10; j++) { clonedContainer = getClone(clonedContainer); copiedContainer = getFrom(copiedContainer); // when copied over itself, of course every characteristic must be constant, else something is // wrong. Assert.assertEquals("j = " + j, nbRefElements, clonedContainer.size()); Assert.assertEquals("j = " + j, nbRefElements, copiedContainer.size()); Assert.assertEquals("j = " + j, clonedCapacity, clonedContainer.capacity()); Assert.assertEquals("j = " + j, copiedCapacity, copiedContainer.capacity()); Assert.assertTrue("j = " + j, clonedContainer.equals(refContainer)); Assert.assertTrue("j = " + j, copiedContainer.equals(refContainer)); } }