@Override public int alleleCount() { return alleles.size(); }
@Override public int sampleCount() { return samples.size(); }
/** * Throws an exception if an index is out of bounds. * * <p> * An element index is valid iff is within [0,{@link #size()}). * </p> * * @param index the query index. * * @throws IllegalArgumentException {@code index} is out of bounds. */ protected void checkIndex(final int index) { if (index < 0) throw new IllegalArgumentException("the index cannot be negative: " + index); if (index >= size()) throw new IllegalArgumentException("the index is equal or larger than the list length: " + index + " >= " + size()); }
/** * Adds a new element to the set. * * <p> * If the element was already in th set nothing will happen and the method will return {@code false}. However, * if the element is new to this set, it will assigned the next index available (equal to the size before addition). * The method will return {@code true} in this case. * </p> * * @param o the object to add. * * @throw IllegalArgumentException if {@code o} is {@code null}. * * @return {@code true} iff the set was modified by this operation. */ @Override public boolean add(final E o) { if (o == null) throw new IllegalArgumentException("the input argument cannot be null"); if (contains(o)) return false; final int nextIndex = size(); elements.add(o); indexByElement.put(o, nextIndex); return true; }
@Test(dataProvider = "initialCapacityElementCountMaxElementData") public void testCompositionBySingleElementAddition(final int initialCapacity, final int elementCount, final int maxElement) { final Random rnd = Utils.getRandomGenerator(); final IndexedSet<Integer> subject = new IndexedSet<>(initialCapacity); final Set<Integer> elementSet = new LinkedHashSet<>(); for (int i = 0; i < elementCount; i++) { final int nextElement = rnd.nextInt(maxElement + 1); final boolean isNewElement = ! elementSet.contains(nextElement); Assert.assertEquals(subject.add(nextElement), elementSet.add(nextElement)); Assert.assertEquals(subject.size(),elementSet.size()); if (isNewElement) Assert.assertEquals(subject.indexOf(nextElement),elementSet.size() - 1); } assertEquals(subject, elementSet); }
/** * Asserts that an indexed-set is equivalent to a insertion-sorted set provided. * @param subject the indexed-set to test. * @param elementSet the insertion-sorted set. */ private void assertEquals(final IndexedSet<Integer> subject, final Set<Integer> elementSet) { Assert.assertEquals(subject.size(), elementSet.size()); final List<Integer> subjectList = subject.asList(); Assert.assertEquals(subjectList.size(),elementSet.size()); final Iterator<Integer> subjectIterator = subject.iterator(); final Iterator<Integer> elementSetIterator = subject.iterator(); final ListIterator<Integer> subjectListIterator = subjectList.listIterator(); while (subjectIterator.hasNext()) { Assert.assertTrue(elementSetIterator.hasNext(),"less elements in indexed-set than in the equivalent hash-set"); Assert.assertTrue(subjectListIterator.hasNext()); final Integer nextElement; Assert.assertEquals(nextElement = subjectIterator.next(),elementSetIterator.next(),"elements in indexed-set do not follow the same order as equivalent linked hash-set's"); Assert.assertEquals(subjectListIterator.next(),nextElement); Assert.assertEquals(subject.indexOf(nextElement),subjectListIterator.previousIndex()); } Assert.assertFalse(elementSetIterator.hasNext()); Assert.assertFalse(subjectListIterator.hasNext()); } }
@Test(dataProvider = "elementCountMaxElementData", dependsOnMethods = {"testCompositionByCollectionConstructor"}) public void testLookupByIndex(final int elementCount, final int maxElement) { final List<Integer> elementList = generateElementCollection(elementCount, maxElement); final IndexedSet<Integer> subject = new IndexedSet<>(elementList); final Set<Integer> elementSet = new LinkedHashSet<>(elementList); final Integer[] elementArray = elementSet.toArray(new Integer[elementSet.size()]); final List<Integer> subjectList = subject.asList(); for (int i = 0; i < subject.size(); i++) { final int element = elementArray[i]; final int subjectElement = subject.get(i); final int subjectListElement = subjectList.get(i); Assert.assertEquals(subjectElement,element); Assert.assertEquals(subjectListElement,element); } }
@Test(dataProvider = "elementCountMaxElementData", dependsOnMethods = {"testCompositionByCollectionConstructor"}) public void testIndexOf(final int elementCount, final int maxElement) { final List<Integer> elementList = generateElementCollection(elementCount, maxElement); final IndexedSet<Integer> subject = new IndexedSet<>(elementList); final Set<Integer> elementSet = new LinkedHashSet<>(elementList); final Integer[] elementArray = elementSet.toArray(new Integer[elementSet.size()]); final List<Integer> subjectList = subject.asList(); for (int i = 0; i < subject.size(); i++) { final int element = elementArray[i]; final int listElement = subjectList.get(i); final int subjectIndex = subject.indexOf(element); Assert.assertEquals(listElement,element); Assert.assertEquals(subjectIndex,i); Assert.assertEquals(subject.indexOf(-element - 1),-1); } }
@Test(dataProvider = "elementCountMaxElementData", dependsOnMethods = {"testCompositionByCollectionConstructor","testIndexOf"}) public void testRemoveHalf(final int elementCount, final int maxElement) { final List<Integer> elementList = generateElementCollection(elementCount, maxElement); final IndexedSet<Integer> subject = new IndexedSet<>(elementList); final Set<Integer> elementSet = new LinkedHashSet<>(elementList); final int removeCount = (subject.size() + 1) / 2; final Random rnd = Utils.getRandomGenerator(); for (int i = 0; i < removeCount; i++) { final int removeIndex = rnd.nextInt(subject.size()); final int removeElement = subject.get(removeIndex); subject.remove(removeElement); elementSet.remove(removeElement); } assertEquals(subject,elementSet); }
@Test(dataProvider = "elementCountMaxElementData", dependsOnMethods = {"testCompositionByCollectionConstructor","testIndexOf"}) public void testRemoveAll(final int elementCount, final int maxElement) { final List<Integer> elementList = generateElementCollection(elementCount, maxElement); final IndexedSet<Integer> subject = new IndexedSet<>(elementList); final Set<Integer> elementSet = new LinkedHashSet<>(elementList); final int removeCount = subject.size(); final Random rnd = Utils.getRandomGenerator(); for (int i = 0; i < removeCount; i++) { final int removeIndex = rnd.nextInt(subject.size()); final int removeElement = subject.get(removeIndex); subject.remove(removeElement); elementSet.remove(removeElement); } assertEquals(subject,elementSet); }
@Test(dataProvider = "elementCountMaxElementData", dependsOnMethods = {"testCompositionByCollectionConstructor","testIndexOf"}) public void testRemoveAndAdd(final int elementCount, final int maxElement) { final List<Integer> elementList = generateElementCollection(elementCount, maxElement); final IndexedSet<Integer> subject = new IndexedSet<>(elementList); final Set<Integer> elementSet = new LinkedHashSet<>(elementList); final int removeCount = subject.size(); final Random rnd = Utils.getRandomGenerator(); for (int i = 0; i < removeCount; i++) { final int removeIndex = rnd.nextInt(subject.size()); final int removeElement = subject.get(removeIndex); subject.remove(removeElement); elementSet.remove(removeElement); } subject.addAll(elementList); elementSet.addAll(elementList); assertEquals(subject, elementSet); }