/** * Constructs a new empty allele-list */ public IndexedAlleleList() { alleles = new IndexedSet<>(); }
@Override public Iterator<E> iterator() { return asList().iterator(); }
@Override public A alleleAt(final int index) { return alleles.get(index); } }
@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); }
@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 = "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") public void testCompositionByCollectionConstructor(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); assertEquals(subject,elementSet); Assert.assertFalse(subject.addAll(elementList)); }
/** * 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; }
@Override public int sampleCount() { return samples.size(); }
@Test(dataProvider = "elementCountMaxElementData", dependsOnMethods = {"testCompositionByCollectionConstructor"}) public void testClear(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); subject.clear(); elementSet.clear(); assertEquals(subject, elementSet); }
@Override public int sampleIndex(final String sample) { return samples.indexOf(sample); }
/** * Returns the element given its index within the set. * @param index the target element's index. * * @throws IllegalArgumentException if {@code index} is not valid; in [0,{@link #size()}). * * @return never {@code null}; as null is not a valid element. */ public E get(final int index) { checkIndex(index); return elements.get(index); }
@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 = "initialCapacityElementCountMaxElementData") public void testCompositionByCollectionAddition(final int initialCapacity, final int elementCount, final int maxElement) { final IndexedSet<Integer> subject = new IndexedSet<>(initialCapacity); final List<Integer> elementList = generateElementCollection(elementCount,maxElement); Assert.assertEquals(subject.addAll(elementList), !elementList.isEmpty()); final Set<Integer> elementSet = new LinkedHashSet<>(elementCount); elementSet.addAll(elementList); assertEquals(subject,elementSet); }
@Override public int alleleCount() { return alleles.size(); }
@Override public int alleleIndex(final A allele) { return alleles.indexOf(allele); }
@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); }
/** * Constructs an empty sample-list. */ public IndexedSampleList() { samples = new IndexedSet<>(0); }