private void testNextOnePloidy() {
final GenotypeAlleleCounts ploidy2 = GenotypeAlleleCounts.first(2);
final GenotypeAlleleCounts first = GenotypeAlleleCounts.first(1);
GenotypeAlleleCounts current = first;
while (!current.containsAllele(MAXIMUM_ALLELE_INDEX + 1)) {
final GenotypeAlleleCounts next = current.next();
Assert.assertEquals(next.minimumAlleleIndex(), next.maximumAlleleIndex());
Assert.assertEquals(next.minimumAlleleIndex(), current.minimumAlleleIndex() + 1);
Assert.assertEquals(next.alleleCountAt(0), 1);
Assert.assertEquals(next.alleleIndexAt(0), next.minimumAlleleIndex());
Assert.assertEquals(next.alleleRankFor(next.minimumAlleleIndex()), 0);
Assert.assertEquals(next.alleleRankFor(next.minimumAlleleIndex() + 1), -2);
Assert.assertEquals(next.alleleCountFor(next.minimumAlleleIndex()), 1);
Assert.assertEquals(next.alleleCountFor(next.minimumAlleleIndex() + 1), 0);
Assert.assertEquals(next.ploidy(), 1);
int[] dest = new int[next.distinctAlleleCount() * 2];
next.copyAlleleCounts(dest, 0);
Assert.assertEquals(dest, new int[] {next.index(), 1});
Assert.assertTrue(next.compareTo(current) > 0);
Assert.assertTrue(current.compareTo(next) < 0);
Assert.assertTrue(next.compareTo(next) == 0);
Assert.assertTrue(next.equals(next));
Assert.assertFalse(next.equals(null));
Assert.assertFalse(next.equals(next.toString()));
Assert.assertFalse(next.equals(ploidy2));
Assert.assertFalse(ploidy2.equals(next));
Assert.assertFalse(next.equals(current));
Assert.assertNotEquals(next.hashCode(), current.hashCode());
Assert.assertFalse(current.equals(next));
Assert.assertEquals(next.index(), current.index() + 1);
Assert.assertEquals(next.ploidy(), current.ploidy());
Assert.assertEquals(
next.asAlleleList(testAlleles),
Collections.singletonList(testAlleles.get(next.maximumAlleleIndex())));
for (int maximumAlleleIndex = 0;
maximumAlleleIndex <= MAXIMUM_ALLELE_INDEX;
maximumAlleleIndex++) {
final int[] expected = new int[maximumAlleleIndex + 1];
if (maximumAlleleIndex >= current.minimumAlleleIndex() + 1)
expected[current.minimumAlleleIndex() + 1] = 1;
Assert.assertEquals(next.alleleCountsByIndex(maximumAlleleIndex), expected);
}
current = next;
}
}
private void testNextZeroPloidy() {
final GenotypeAlleleCounts first = GenotypeAlleleCounts.first(0);
final GenotypeAlleleCounts next = first.next();
Assert.assertEquals(first, next);
Assert.assertEquals(first.compareTo(next), 0);
Assert.assertEquals(next.compareTo(first), 0);
Assert.assertEquals(next.distinctAlleleCount(), 0);
Assert.assertEquals(next.ploidy(), 0);
Assert.assertEquals(next.index(), 0);
Assert.assertEquals(next.asAlleleList(testAlleles), Collections.EMPTY_LIST);
for (int maximumAlleleIndex = 0; maximumAlleleIndex <= 10; maximumAlleleIndex++) {
final int[] expected = new int[maximumAlleleIndex + 1];
Assert.assertEquals(next.alleleCountsByIndex(maximumAlleleIndex), expected);
}
first.increase();
Assert.assertEquals(first, next);
}
private void testPloidyTwoOrMore(final int ploidy) {
if (ploidy < 2) throw new IllegalArgumentException();
GenotypeAlleleCounts current = GenotypeAlleleCounts.first(ploidy);
while (!current.containsAllele(MAXIMUM_ALLELE_INDEX + 1)) {
final GenotypeAlleleCounts next = current.next();
if (current.distinctAlleleCount() == 1) {
Assert.assertEquals(next.maximumAlleleIndex(), current.maximumAlleleIndex() + 1);
Assert.assertEquals(next.distinctAlleleCount(), 2);
Assert.assertEquals(next.minimumAlleleIndex(), 0);
} else {
Assert.assertEquals(next.maximumAlleleIndex(), current.maximumAlleleIndex());
Assert.assertEquals(
next.minimumAlleleIndex(),
current.alleleCountAt(0) > 1
? 0
: current.alleleCountAt(0) == 1
? current.minimumAlleleIndex() + 1
: current.minimumAlleleIndex());
}
// Checking on 0's new count and current.minAllele + 1 alleles.
Assert.assertEquals(
next.alleleCountFor(0), current.alleleCountFor(current.minimumAlleleIndex()) - 1);
Assert.assertEquals(
next.alleleCountFor(current.minimumAlleleIndex() + 1),
current.alleleCountFor(current.minimumAlleleIndex() + 1) + 1);
// Checks current.minAllele count
Assert.assertEquals(
next.alleleCountFor(current.minimumAlleleIndex()),
current.minimumAlleleIndex() == 0 ? current.alleleCountAt(0) - 1 : 0);
int totalCountSum = 0;
final int[] expectedAlleleCountsByIndex =
new int[Math.max(MAXIMUM_ALLELE_INDEX, next.maximumAlleleIndex()) + 1];
for (int i = 0; i < next.distinctAlleleCount(); i++) {
final int count = next.alleleCountAt(i);
final int index = next.alleleIndexAt(i);
expectedAlleleCountsByIndex[index] = count;
// Check consistency of alleleCountAt(x) and alleleCountFor(alleleIndexAt(x))
Assert.assertEquals(next.alleleCountFor(index), count);
totalCountSum += count;
// Check on counts of, in theory, unaffected allele counts.
if (index > current.minimumAlleleIndex() + 1)
Assert.assertEquals(next.alleleCountFor(index), current.alleleCountFor(index));
}
Assert.assertTrue(
Arrays.equals(
next.alleleCountsByIndex(Math.max(MAXIMUM_ALLELE_INDEX, next.maximumAlleleIndex())),
expectedAlleleCountsByIndex));
Assert.assertEquals(totalCountSum, ploidy);
Assert.assertTrue(next.compareTo(current) > 0);
Assert.assertTrue(current.compareTo(next) < 0);
Assert.assertTrue(next.compareTo(next) == 0);
Assert.assertTrue(next.equals(next));
Assert.assertFalse(next.equals(current));
Assert.assertFalse(current.equals(next));
Assert.assertEquals(next.index(), current.index() + 1);
Assert.assertEquals(next.ploidy(), ploidy);
// Check asAlleleList.
final List<Allele> expectedList = new ArrayList<>(ploidy);
for (int i = 0; i < next.distinctAlleleCount(); i++) {
for (int j = 0; j < next.alleleCountAt(i); j++) {
expectedList.add(testAlleles.get(next.alleleIndexAt(i)));
}
}
Assert.assertEquals(next.asAlleleList(testAlleles), expectedList);
current = next;
}
}
