Summary

Test suite

Test case 1

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("centromere");
  2: RawStreamSequence rawStreamSequence0 = new RawStreamSequence(emblStreamSequence0);
  3: Bases bases0 = new Bases(rawStreamSequence0);
  4: Strand strand0 = bases0.getForwardStrand();
  5: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
  6: cumulativeGCSkewAlgorithm0.getMinimumInternal();

Test case 2

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("E1J*nMUi");
  2: Bases bases0 = new Bases(emblStreamSequence0);
  3: Strand strand0 = bases0.getReverseStrand();
  4: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
  5: int int0 = cumulativeGCSkewAlgorithm0.getValueCount();
  6: assertEquals(1, int0);
  7: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());

Test case 3

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("centromere");
  2: RawStreamSequence rawStreamSequence0 = new RawStreamSequence(emblStreamSequence0);
  3: Bases bases0 = new Bases(rawStreamSequence0);
  4: Strand strand0 = bases0.getForwardStrand();
  5: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
  6: Float float0 = cumulativeGCSkewAlgorithm0.getMaximumInternal();
  7: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
  8: assertEquals(1.0F, (float)float0, 0.01F);

Test case 4

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("3\"ld32Y");
  2: Bases bases0 = new Bases(fastaStreamSequence0);
  3: Strand strand0 = bases0.getForwardStrand();
  4: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
  5: float[] floatArray0 = new float[7];
  6: cumulativeGCSkewAlgorithm0.getValues(0, (-5), floatArray0);
  7: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
  8: assertArrayEquals(new float[] {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F}, floatArray0, 0.01F);

Test case 5

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("K.?zfgN~e");
  2: Bases bases0 = new Bases(genbankStreamSequence0);
  3: Strand strand0 = bases0.getForwardStrand();
  4: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
  5: float[] floatArray0 = new float[5];
  6: cumulativeGCSkewAlgorithm0.getValues(372, 95401, floatArray0);

Test case 6

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("3\"ld32Y");
  2: Bases bases0 = new Bases(fastaStreamSequence0);
  3: Strand strand0 = bases0.getForwardStrand();
  4: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
  5: float[] floatArray0 = new float[7];
  6: cumulativeGCSkewAlgorithm0.getValues(0, 1637, floatArray0);
  7: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
  8: assertArrayEquals(new float[] {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F}, floatArray0, 0.01F);

Test case 7

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("3\"ld32Y");
  2: assertEquals(0, fastaStreamSequence0.getCCount());
  3: assertEquals(0, fastaStreamSequence0.getTCount());
  4: assertEquals(0, fastaStreamSequence0.getACount());
  5: assertEquals(7, fastaStreamSequence0.getOtherCount());
  6: assertEquals(7, fastaStreamSequence0.length());
  7: assertEquals(4, fastaStreamSequence0.getFormatType());
  8: assertEquals(0, fastaStreamSequence0.getGCount());
  9: assertNotNull(fastaStreamSequence0);
 10: 
 11: Bases bases0 = new Bases(fastaStreamSequence0);
 12: assertEquals(5, Bases.MAX_PRIORITY);
 13: assertEquals(2, Bases.REVERSE);
 14: assertEquals(0, Bases.MEDIUM_PRIORITY);
 15: assertEquals((-5), Bases.MIN_PRIORITY);
 16: assertEquals(1, Bases.FORWARD);
 17: assertEquals(0, fastaStreamSequence0.getCCount());
 18: assertEquals(0, fastaStreamSequence0.getTCount());
 19: assertEquals(0, fastaStreamSequence0.getACount());
 20: assertEquals(7, fastaStreamSequence0.getOtherCount());
 21: assertEquals(7, fastaStreamSequence0.length());
 22: assertEquals(4, fastaStreamSequence0.getFormatType());
 23: assertEquals(0, fastaStreamSequence0.getGCount());
 24: assertNotNull(bases0);
 25: 
 26: Strand strand0 = bases0.getForwardStrand();
 27: assertEquals(5, Bases.MAX_PRIORITY);
 28: assertEquals(2, Bases.REVERSE);
 29: assertEquals(0, Bases.MEDIUM_PRIORITY);
 30: assertEquals((-5), Bases.MIN_PRIORITY);
 31: assertEquals(1, Bases.FORWARD);
 32: assertEquals(2, Strand.REVERSE);
 33: assertEquals(1, Strand.FORWARD);
 34: assertEquals(0, fastaStreamSequence0.getCCount());
 35: assertEquals(0, fastaStreamSequence0.getTCount());
 36: assertEquals(0, fastaStreamSequence0.getACount());
 37: assertEquals(7, fastaStreamSequence0.getOtherCount());
 38: assertEquals(7, fastaStreamSequence0.length());
 39: assertEquals(4, fastaStreamSequence0.getFormatType());
 40: assertEquals(0, fastaStreamSequence0.getGCount());
 41: assertEquals(1, strand0.getDirection());
 42: assertTrue(strand0.isForwardStrand());
 43: assertNotNull(strand0);
 44: 
 45: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 46: assertEquals(5, Bases.MAX_PRIORITY);
 47: assertEquals(2, Bases.REVERSE);
 48: assertEquals(0, Bases.MEDIUM_PRIORITY);
 49: assertEquals((-5), Bases.MIN_PRIORITY);
 50: assertEquals(1, Bases.FORWARD);
 51: assertEquals(2, Strand.REVERSE);
 52: assertEquals(1, Strand.FORWARD);
 53: assertEquals(0, fastaStreamSequence0.getCCount());
 54: assertEquals(0, fastaStreamSequence0.getTCount());
 55: assertEquals(0, fastaStreamSequence0.getACount());
 56: assertEquals(7, fastaStreamSequence0.getOtherCount());
 57: assertEquals(7, fastaStreamSequence0.length());
 58: assertEquals(4, fastaStreamSequence0.getFormatType());
 59: assertEquals(0, fastaStreamSequence0.getGCount());
 60: assertEquals(1, strand0.getDirection());
 61: assertTrue(strand0.isForwardStrand());
 62: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 63: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 64: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 65: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 66: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 67: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 68: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 69: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 70: assertNotNull(cumulativeGCSkewAlgorithm0);
 71: 
 72: Integer integer0 = cumulativeGCSkewAlgorithm0.getDefaultWindowSize();
 73: assertEquals(60, (int)integer0);
 74: assertEquals(5, Bases.MAX_PRIORITY);
 75: assertEquals(2, Bases.REVERSE);
 76: assertEquals(0, Bases.MEDIUM_PRIORITY);
 77: assertEquals((-5), Bases.MIN_PRIORITY);
 78: assertEquals(1, Bases.FORWARD);
 79: assertEquals(2, Strand.REVERSE);
 80: assertEquals(1, Strand.FORWARD);
 81: assertEquals(0, fastaStreamSequence0.getCCount());
 82: assertEquals(0, fastaStreamSequence0.getTCount());
 83: assertEquals(0, fastaStreamSequence0.getACount());
 84: assertEquals(7, fastaStreamSequence0.getOtherCount());
 85: assertEquals(7, fastaStreamSequence0.length());
 86: assertEquals(4, fastaStreamSequence0.getFormatType());
 87: assertEquals(0, fastaStreamSequence0.getGCount());
 88: assertEquals(1, strand0.getDirection());
 89: assertTrue(strand0.isForwardStrand());
 90: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 91: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 92: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 93: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 94: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 95: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 96: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 97: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 98: assertNotNull(integer0);

Test case 8

  1: BioJavaSequence bioJavaSequence0 = new BioJavaSequence((SymbolList) null);
  2: assertNotNull(bioJavaSequence0);
  3: 
  4: Bases bases0 = new Bases(bioJavaSequence0);
  5: assertEquals((-5), Bases.MIN_PRIORITY);
  6: assertEquals(1, Bases.FORWARD);
  7: assertEquals(0, Bases.MEDIUM_PRIORITY);
  8: assertEquals(5, Bases.MAX_PRIORITY);
  9: assertEquals(2, Bases.REVERSE);
 10: assertNotNull(bases0);
 11: 
 12: Strand strand0 = bases0.getForwardStrand();
 13: assertEquals((-5), Bases.MIN_PRIORITY);
 14: assertEquals(1, Bases.FORWARD);
 15: assertEquals(0, Bases.MEDIUM_PRIORITY);
 16: assertEquals(5, Bases.MAX_PRIORITY);
 17: assertEquals(2, Bases.REVERSE);
 18: assertEquals(1, Strand.FORWARD);
 19: assertEquals(2, Strand.REVERSE);
 20: assertEquals(1, strand0.getDirection());
 21: assertTrue(strand0.isForwardStrand());
 22: assertNotNull(strand0);
 23: 
 24: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 25: assertEquals((-5), Bases.MIN_PRIORITY);
 26: assertEquals(1, Bases.FORWARD);
 27: assertEquals(0, Bases.MEDIUM_PRIORITY);
 28: assertEquals(5, Bases.MAX_PRIORITY);
 29: assertEquals(2, Bases.REVERSE);
 30: assertEquals(1, Strand.FORWARD);
 31: assertEquals(2, Strand.REVERSE);
 32: assertEquals(1, strand0.getDirection());
 33: assertTrue(strand0.isForwardStrand());
 34: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 35: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 36: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 37: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 38: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 39: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 40: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 41: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 42: assertNotNull(cumulativeGCSkewAlgorithm0);
 43: 
 44: Integer integer0 = cumulativeGCSkewAlgorithm0.getDefaultMaxWindowSize();
 45: assertEquals(5000, (int)integer0);
 46: assertEquals((-5), Bases.MIN_PRIORITY);
 47: assertEquals(1, Bases.FORWARD);
 48: assertEquals(0, Bases.MEDIUM_PRIORITY);
 49: assertEquals(5, Bases.MAX_PRIORITY);
 50: assertEquals(2, Bases.REVERSE);
 51: assertEquals(1, Strand.FORWARD);
 52: assertEquals(2, Strand.REVERSE);
 53: assertEquals(1, strand0.getDirection());
 54: assertTrue(strand0.isForwardStrand());
 55: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 56: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 57: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 58: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 59: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 60: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 61: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 62: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 63: assertNotNull(integer0);

Test case 9

  1: BioJavaSequence bioJavaSequence0 = new BioJavaSequence((SymbolList) null);
  2: assertNotNull(bioJavaSequence0);
  3: 
  4: Bases bases0 = new Bases(bioJavaSequence0);
  5: assertEquals(5, Bases.MAX_PRIORITY);
  6: assertEquals(1, Bases.FORWARD);
  7: assertEquals((-5), Bases.MIN_PRIORITY);
  8: assertEquals(0, Bases.MEDIUM_PRIORITY);
  9: assertEquals(2, Bases.REVERSE);
 10: assertNotNull(bases0);
 11: 
 12: Strand strand0 = bases0.getForwardStrand();
 13: assertEquals(5, Bases.MAX_PRIORITY);
 14: assertEquals(1, Bases.FORWARD);
 15: assertEquals((-5), Bases.MIN_PRIORITY);
 16: assertEquals(0, Bases.MEDIUM_PRIORITY);
 17: assertEquals(2, Bases.REVERSE);
 18: assertEquals(2, Strand.REVERSE);
 19: assertEquals(1, Strand.FORWARD);
 20: assertEquals(1, strand0.getDirection());
 21: assertTrue(strand0.isForwardStrand());
 22: assertNotNull(strand0);
 23: 
 24: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 25: assertEquals(5, Bases.MAX_PRIORITY);
 26: assertEquals(1, Bases.FORWARD);
 27: assertEquals((-5), Bases.MIN_PRIORITY);
 28: assertEquals(0, Bases.MEDIUM_PRIORITY);
 29: assertEquals(2, Bases.REVERSE);
 30: assertEquals(2, Strand.REVERSE);
 31: assertEquals(1, Strand.FORWARD);
 32: assertEquals(1, strand0.getDirection());
 33: assertTrue(strand0.isForwardStrand());
 34: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 35: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 36: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 37: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 38: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 39: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 40: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 41: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 42: assertNotNull(cumulativeGCSkewAlgorithm0);
 43: 
 44: Integer integer0 = cumulativeGCSkewAlgorithm0.getDefaultMinWindowSize();
 45: assertEquals(10, (int)integer0);
 46: assertEquals(5, Bases.MAX_PRIORITY);
 47: assertEquals(1, Bases.FORWARD);
 48: assertEquals((-5), Bases.MIN_PRIORITY);
 49: assertEquals(0, Bases.MEDIUM_PRIORITY);
 50: assertEquals(2, Bases.REVERSE);
 51: assertEquals(2, Strand.REVERSE);
 52: assertEquals(1, Strand.FORWARD);
 53: assertEquals(1, strand0.getDirection());
 54: assertTrue(strand0.isForwardStrand());
 55: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 56: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 57: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 58: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 59: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 60: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 61: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 62: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 63: assertNotNull(integer0);

Test case 10

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("3\"ld32Y");
  2: assertEquals(0, fastaStreamSequence0.getTCount());
  3: assertEquals(0, fastaStreamSequence0.getCCount());
  4: assertEquals(0, fastaStreamSequence0.getACount());
  5: assertEquals(7, fastaStreamSequence0.length());
  6: assertEquals(0, fastaStreamSequence0.getGCount());
  7: assertEquals(7, fastaStreamSequence0.getOtherCount());
  8: assertEquals(4, fastaStreamSequence0.getFormatType());
  9: assertNotNull(fastaStreamSequence0);
 10: 
 11: Bases bases0 = new Bases(fastaStreamSequence0);
 12: assertEquals(5, Bases.MAX_PRIORITY);
 13: assertEquals((-5), Bases.MIN_PRIORITY);
 14: assertEquals(1, Bases.FORWARD);
 15: assertEquals(2, Bases.REVERSE);
 16: assertEquals(0, Bases.MEDIUM_PRIORITY);
 17: assertEquals(0, fastaStreamSequence0.getTCount());
 18: assertEquals(0, fastaStreamSequence0.getCCount());
 19: assertEquals(0, fastaStreamSequence0.getACount());
 20: assertEquals(7, fastaStreamSequence0.length());
 21: assertEquals(0, fastaStreamSequence0.getGCount());
 22: assertEquals(7, fastaStreamSequence0.getOtherCount());
 23: assertEquals(4, fastaStreamSequence0.getFormatType());
 24: assertNotNull(bases0);
 25: 
 26: Strand strand0 = bases0.getForwardStrand();
 27: assertEquals(5, Bases.MAX_PRIORITY);
 28: assertEquals((-5), Bases.MIN_PRIORITY);
 29: assertEquals(1, Bases.FORWARD);
 30: assertEquals(2, Bases.REVERSE);
 31: assertEquals(0, Bases.MEDIUM_PRIORITY);
 32: assertEquals(2, Strand.REVERSE);
 33: assertEquals(1, Strand.FORWARD);
 34: assertEquals(0, fastaStreamSequence0.getTCount());
 35: assertEquals(0, fastaStreamSequence0.getCCount());
 36: assertEquals(0, fastaStreamSequence0.getACount());
 37: assertEquals(7, fastaStreamSequence0.length());
 38: assertEquals(0, fastaStreamSequence0.getGCount());
 39: assertEquals(7, fastaStreamSequence0.getOtherCount());
 40: assertEquals(4, fastaStreamSequence0.getFormatType());
 41: assertEquals(1, strand0.getDirection());
 42: assertTrue(strand0.isForwardStrand());
 43: assertNotNull(strand0);
 44: 
 45: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 46: assertEquals(5, Bases.MAX_PRIORITY);
 47: assertEquals((-5), Bases.MIN_PRIORITY);
 48: assertEquals(1, Bases.FORWARD);
 49: assertEquals(2, Bases.REVERSE);
 50: assertEquals(0, Bases.MEDIUM_PRIORITY);
 51: assertEquals(2, Strand.REVERSE);
 52: assertEquals(1, Strand.FORWARD);
 53: assertEquals(0, fastaStreamSequence0.getTCount());
 54: assertEquals(0, fastaStreamSequence0.getCCount());
 55: assertEquals(0, fastaStreamSequence0.getACount());
 56: assertEquals(7, fastaStreamSequence0.length());
 57: assertEquals(0, fastaStreamSequence0.getGCount());
 58: assertEquals(7, fastaStreamSequence0.getOtherCount());
 59: assertEquals(4, fastaStreamSequence0.getFormatType());
 60: assertEquals(1, strand0.getDirection());
 61: assertTrue(strand0.isForwardStrand());
 62: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 63: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 64: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 65: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 66: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 67: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 68: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 69: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 70: assertNotNull(cumulativeGCSkewAlgorithm0);
 71: 
 72: Integer integer0 = cumulativeGCSkewAlgorithm0.getDefaultStepSize(5);
 73: assertEquals(5, Bases.MAX_PRIORITY);
 74: assertEquals((-5), Bases.MIN_PRIORITY);
 75: assertEquals(1, Bases.FORWARD);
 76: assertEquals(2, Bases.REVERSE);
 77: assertEquals(0, Bases.MEDIUM_PRIORITY);
 78: assertEquals(2, Strand.REVERSE);
 79: assertEquals(1, Strand.FORWARD);
 80: assertEquals(0, fastaStreamSequence0.getTCount());
 81: assertEquals(0, fastaStreamSequence0.getCCount());
 82: assertEquals(0, fastaStreamSequence0.getACount());
 83: assertEquals(7, fastaStreamSequence0.length());
 84: assertEquals(0, fastaStreamSequence0.getGCount());
 85: assertEquals(7, fastaStreamSequence0.getOtherCount());
 86: assertEquals(4, fastaStreamSequence0.getFormatType());
 87: assertEquals(1, strand0.getDirection());
 88: assertTrue(strand0.isForwardStrand());
 89: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 90: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 91: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 92: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 93: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 94: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 95: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 96: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 97: assertNull(integer0);

Test case 11

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("K.?zfgN~e");
  2: assertEquals(8, genbankStreamSequence0.getOtherCount());
  3: assertEquals(2, genbankStreamSequence0.getFormatType());
  4: assertEquals(9, genbankStreamSequence0.length());
  5: assertEquals(1, genbankStreamSequence0.getGCount());
  6: assertEquals(0, genbankStreamSequence0.getACount());
  7: assertNull(genbankStreamSequence0.getHeader());
  8: assertEquals(0, genbankStreamSequence0.getCCount());
  9: assertEquals(0, genbankStreamSequence0.getTCount());
 10: assertNotNull(genbankStreamSequence0);
 11: 
 12: Bases bases0 = new Bases(genbankStreamSequence0);
 13: assertEquals(2, Bases.REVERSE);
 14: assertEquals(0, Bases.MEDIUM_PRIORITY);
 15: assertEquals(5, Bases.MAX_PRIORITY);
 16: assertEquals(1, Bases.FORWARD);
 17: assertEquals((-5), Bases.MIN_PRIORITY);
 18: assertEquals(8, genbankStreamSequence0.getOtherCount());
 19: assertEquals(2, genbankStreamSequence0.getFormatType());
 20: assertEquals(9, genbankStreamSequence0.length());
 21: assertEquals(1, genbankStreamSequence0.getGCount());
 22: assertEquals(0, genbankStreamSequence0.getACount());
 23: assertNull(genbankStreamSequence0.getHeader());
 24: assertEquals(0, genbankStreamSequence0.getCCount());
 25: assertEquals(0, genbankStreamSequence0.getTCount());
 26: assertNotNull(bases0);
 27: 
 28: Strand strand0 = bases0.getForwardStrand();
 29: assertEquals(2, Bases.REVERSE);
 30: assertEquals(0, Bases.MEDIUM_PRIORITY);
 31: assertEquals(5, Bases.MAX_PRIORITY);
 32: assertEquals(1, Bases.FORWARD);
 33: assertEquals((-5), Bases.MIN_PRIORITY);
 34: assertEquals(2, Strand.REVERSE);
 35: assertEquals(1, Strand.FORWARD);
 36: assertEquals(8, genbankStreamSequence0.getOtherCount());
 37: assertEquals(2, genbankStreamSequence0.getFormatType());
 38: assertEquals(9, genbankStreamSequence0.length());
 39: assertEquals(1, genbankStreamSequence0.getGCount());
 40: assertEquals(0, genbankStreamSequence0.getACount());
 41: assertNull(genbankStreamSequence0.getHeader());
 42: assertEquals(0, genbankStreamSequence0.getCCount());
 43: assertEquals(0, genbankStreamSequence0.getTCount());
 44: assertTrue(strand0.isForwardStrand());
 45: assertEquals(1, strand0.getDirection());
 46: assertNotNull(strand0);
 47: 
 48: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 49: assertEquals(2, Bases.REVERSE);
 50: assertEquals(0, Bases.MEDIUM_PRIORITY);
 51: assertEquals(5, Bases.MAX_PRIORITY);
 52: assertEquals(1, Bases.FORWARD);
 53: assertEquals((-5), Bases.MIN_PRIORITY);
 54: assertEquals(2, Strand.REVERSE);
 55: assertEquals(1, Strand.FORWARD);
 56: assertEquals(8, genbankStreamSequence0.getOtherCount());
 57: assertEquals(2, genbankStreamSequence0.getFormatType());
 58: assertEquals(9, genbankStreamSequence0.length());
 59: assertEquals(1, genbankStreamSequence0.getGCount());
 60: assertEquals(0, genbankStreamSequence0.getACount());
 61: assertNull(genbankStreamSequence0.getHeader());
 62: assertEquals(0, genbankStreamSequence0.getCCount());
 63: assertEquals(0, genbankStreamSequence0.getTCount());
 64: assertTrue(strand0.isForwardStrand());
 65: assertEquals(1, strand0.getDirection());
 66: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 67: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 68: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 69: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 70: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 71: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 72: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 73: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 74: assertNotNull(cumulativeGCSkewAlgorithm0);
 75: 
 76: Integer integer0 = cumulativeGCSkewAlgorithm0.getDefaultStepSize(4331);
 77: assertEquals(433, (int)integer0);
 78: assertEquals(2, Bases.REVERSE);
 79: assertEquals(0, Bases.MEDIUM_PRIORITY);
 80: assertEquals(5, Bases.MAX_PRIORITY);
 81: assertEquals(1, Bases.FORWARD);
 82: assertEquals((-5), Bases.MIN_PRIORITY);
 83: assertEquals(2, Strand.REVERSE);
 84: assertEquals(1, Strand.FORWARD);
 85: assertEquals(8, genbankStreamSequence0.getOtherCount());
 86: assertEquals(2, genbankStreamSequence0.getFormatType());
 87: assertEquals(9, genbankStreamSequence0.length());
 88: assertEquals(1, genbankStreamSequence0.getGCount());
 89: assertEquals(0, genbankStreamSequence0.getACount());
 90: assertNull(genbankStreamSequence0.getHeader());
 91: assertEquals(0, genbankStreamSequence0.getCCount());
 92: assertEquals(0, genbankStreamSequence0.getTCount());
 93: assertTrue(strand0.isForwardStrand());
 94: assertEquals(1, strand0.getDirection());
 95: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 96: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 97: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 98: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 99: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
100: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
101: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
102: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
103: assertNotNull(integer0);

Test case 12

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("");
  2: assertEquals(0, emblStreamSequence0.length());
  3: assertNull(emblStreamSequence0.getHeader());
  4: assertEquals(1, emblStreamSequence0.getFormatType());
  5: assertEquals(0, emblStreamSequence0.getACount());
  6: assertEquals(0, emblStreamSequence0.getTCount());
  7: assertEquals(0, emblStreamSequence0.getGCount());
  8: assertEquals(0, emblStreamSequence0.getCCount());
  9: assertEquals(0, emblStreamSequence0.getOtherCount());
 10: assertNotNull(emblStreamSequence0);
 11: 
 12: RawStreamSequence rawStreamSequence0 = new RawStreamSequence(emblStreamSequence0);
 13: assertEquals(0, emblStreamSequence0.length());
 14: assertNull(emblStreamSequence0.getHeader());
 15: assertEquals(1, emblStreamSequence0.getFormatType());
 16: assertEquals(0, emblStreamSequence0.getACount());
 17: assertEquals(0, emblStreamSequence0.getTCount());
 18: assertEquals(0, emblStreamSequence0.getGCount());
 19: assertEquals(0, emblStreamSequence0.getCCount());
 20: assertEquals(0, emblStreamSequence0.getOtherCount());
 21: assertEquals(0, rawStreamSequence0.length());
 22: assertEquals(0, rawStreamSequence0.getCCount());
 23: assertEquals(0, rawStreamSequence0.getACount());
 24: assertEquals(0, rawStreamSequence0.getGCount());
 25: assertEquals(3, rawStreamSequence0.getFormatType());
 26: assertEquals(0, rawStreamSequence0.getOtherCount());
 27: assertEquals(0, rawStreamSequence0.getTCount());
 28: assertNotNull(rawStreamSequence0);
 29: 
 30: Bases bases0 = new Bases(rawStreamSequence0);
 31: assertEquals((-5), Bases.MIN_PRIORITY);
 32: assertEquals(0, Bases.MEDIUM_PRIORITY);
 33: assertEquals(2, Bases.REVERSE);
 34: assertEquals(1, Bases.FORWARD);
 35: assertEquals(5, Bases.MAX_PRIORITY);
 36: assertEquals(0, emblStreamSequence0.length());
 37: assertNull(emblStreamSequence0.getHeader());
 38: assertEquals(1, emblStreamSequence0.getFormatType());
 39: assertEquals(0, emblStreamSequence0.getACount());
 40: assertEquals(0, emblStreamSequence0.getTCount());
 41: assertEquals(0, emblStreamSequence0.getGCount());
 42: assertEquals(0, emblStreamSequence0.getCCount());
 43: assertEquals(0, emblStreamSequence0.getOtherCount());
 44: assertEquals(0, rawStreamSequence0.length());
 45: assertEquals(0, rawStreamSequence0.getCCount());
 46: assertEquals(0, rawStreamSequence0.getACount());
 47: assertEquals(0, rawStreamSequence0.getGCount());
 48: assertEquals(3, rawStreamSequence0.getFormatType());
 49: assertEquals(0, rawStreamSequence0.getOtherCount());
 50: assertEquals(0, rawStreamSequence0.getTCount());
 51: assertNotNull(bases0);
 52: 
 53: Strand strand0 = bases0.getForwardStrand();
 54: assertEquals((-5), Bases.MIN_PRIORITY);
 55: assertEquals(0, Bases.MEDIUM_PRIORITY);
 56: assertEquals(2, Bases.REVERSE);
 57: assertEquals(1, Bases.FORWARD);
 58: assertEquals(5, Bases.MAX_PRIORITY);
 59: assertEquals(2, Strand.REVERSE);
 60: assertEquals(1, Strand.FORWARD);
 61: assertEquals(0, emblStreamSequence0.length());
 62: assertNull(emblStreamSequence0.getHeader());
 63: assertEquals(1, emblStreamSequence0.getFormatType());
 64: assertEquals(0, emblStreamSequence0.getACount());
 65: assertEquals(0, emblStreamSequence0.getTCount());
 66: assertEquals(0, emblStreamSequence0.getGCount());
 67: assertEquals(0, emblStreamSequence0.getCCount());
 68: assertEquals(0, emblStreamSequence0.getOtherCount());
 69: assertEquals(0, rawStreamSequence0.length());
 70: assertEquals(0, rawStreamSequence0.getCCount());
 71: assertEquals(0, rawStreamSequence0.getACount());
 72: assertEquals(0, rawStreamSequence0.getGCount());
 73: assertEquals(3, rawStreamSequence0.getFormatType());
 74: assertEquals(0, rawStreamSequence0.getOtherCount());
 75: assertEquals(0, rawStreamSequence0.getTCount());
 76: assertEquals(1, strand0.getDirection());
 77: assertTrue(strand0.isForwardStrand());
 78: assertNotNull(strand0);
 79: 
 80: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 81: assertEquals((-5), Bases.MIN_PRIORITY);
 82: assertEquals(0, Bases.MEDIUM_PRIORITY);
 83: assertEquals(2, Bases.REVERSE);
 84: assertEquals(1, Bases.FORWARD);
 85: assertEquals(5, Bases.MAX_PRIORITY);
 86: assertEquals(2, Strand.REVERSE);
 87: assertEquals(1, Strand.FORWARD);
 88: assertEquals(0, emblStreamSequence0.length());
 89: assertNull(emblStreamSequence0.getHeader());
 90: assertEquals(1, emblStreamSequence0.getFormatType());
 91: assertEquals(0, emblStreamSequence0.getACount());
 92: assertEquals(0, emblStreamSequence0.getTCount());
 93: assertEquals(0, emblStreamSequence0.getGCount());
 94: assertEquals(0, emblStreamSequence0.getCCount());
 95: assertEquals(0, emblStreamSequence0.getOtherCount());
 96: assertEquals(0, rawStreamSequence0.length());
 97: assertEquals(0, rawStreamSequence0.getCCount());
 98: assertEquals(0, rawStreamSequence0.getACount());
 99: assertEquals(0, rawStreamSequence0.getGCount());
100: assertEquals(3, rawStreamSequence0.getFormatType());
101: assertEquals(0, rawStreamSequence0.getOtherCount());
102: assertEquals(0, rawStreamSequence0.getTCount());
103: assertEquals(1, strand0.getDirection());
104: assertTrue(strand0.isForwardStrand());
105: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
106: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
107: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
108: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
109: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
110: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
111: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
112: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
113: assertNotNull(cumulativeGCSkewAlgorithm0);
114: 
115: Float float0 = cumulativeGCSkewAlgorithm0.getAverage();
116: assertEquals(0.0F, (float)float0, 0.01F);
117: assertEquals((-5), Bases.MIN_PRIORITY);
118: assertEquals(0, Bases.MEDIUM_PRIORITY);
119: assertEquals(2, Bases.REVERSE);
120: assertEquals(1, Bases.FORWARD);
121: assertEquals(5, Bases.MAX_PRIORITY);
122: assertEquals(2, Strand.REVERSE);
123: assertEquals(1, Strand.FORWARD);
124: assertEquals(0, emblStreamSequence0.length());
125: assertNull(emblStreamSequence0.getHeader());
126: assertEquals(1, emblStreamSequence0.getFormatType());
127: assertEquals(0, emblStreamSequence0.getACount());
128: assertEquals(0, emblStreamSequence0.getTCount());
129: assertEquals(0, emblStreamSequence0.getGCount());
130: assertEquals(0, emblStreamSequence0.getCCount());
131: assertEquals(0, emblStreamSequence0.getOtherCount());
132: assertEquals(0, rawStreamSequence0.length());
133: assertEquals(0, rawStreamSequence0.getCCount());
134: assertEquals(0, rawStreamSequence0.getACount());
135: assertEquals(0, rawStreamSequence0.getGCount());
136: assertEquals(3, rawStreamSequence0.getFormatType());
137: assertEquals(0, rawStreamSequence0.getOtherCount());
138: assertEquals(0, rawStreamSequence0.getTCount());
139: assertEquals(1, strand0.getDirection());
140: assertTrue(strand0.isForwardStrand());
141: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
142: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
143: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
144: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
145: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
146: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
147: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
148: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
149: assertNotNull(float0);

Test case 13

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("centromere");
  2: assertEquals(0, emblStreamSequence0.getACount());
  3: assertEquals(1, emblStreamSequence0.getFormatType());
  4: assertEquals(1, emblStreamSequence0.getTCount());
  5: assertNull(emblStreamSequence0.getHeader());
  6: assertEquals(8, emblStreamSequence0.getOtherCount());
  7: assertEquals(1, emblStreamSequence0.getCCount());
  8: assertEquals(10, emblStreamSequence0.length());
  9: assertEquals(0, emblStreamSequence0.getGCount());
 10: assertNotNull(emblStreamSequence0);
 11: 
 12: RawStreamSequence rawStreamSequence0 = new RawStreamSequence(emblStreamSequence0);
 13: assertEquals(0, emblStreamSequence0.getACount());
 14: assertEquals(1, emblStreamSequence0.getFormatType());
 15: assertEquals(1, emblStreamSequence0.getTCount());
 16: assertNull(emblStreamSequence0.getHeader());
 17: assertEquals(8, emblStreamSequence0.getOtherCount());
 18: assertEquals(1, emblStreamSequence0.getCCount());
 19: assertEquals(10, emblStreamSequence0.length());
 20: assertEquals(0, emblStreamSequence0.getGCount());
 21: assertEquals(10, rawStreamSequence0.length());
 22: assertEquals(8, rawStreamSequence0.getOtherCount());
 23: assertEquals(1, rawStreamSequence0.getTCount());
 24: assertEquals(1, rawStreamSequence0.getCCount());
 25: assertEquals(0, rawStreamSequence0.getGCount());
 26: assertEquals(3, rawStreamSequence0.getFormatType());
 27: assertEquals(0, rawStreamSequence0.getACount());
 28: assertNotNull(rawStreamSequence0);
 29: 
 30: Bases bases0 = new Bases(rawStreamSequence0);
 31: assertEquals((-5), Bases.MIN_PRIORITY);
 32: assertEquals(0, Bases.MEDIUM_PRIORITY);
 33: assertEquals(2, Bases.REVERSE);
 34: assertEquals(1, Bases.FORWARD);
 35: assertEquals(5, Bases.MAX_PRIORITY);
 36: assertEquals(0, emblStreamSequence0.getACount());
 37: assertEquals(1, emblStreamSequence0.getFormatType());
 38: assertEquals(1, emblStreamSequence0.getTCount());
 39: assertNull(emblStreamSequence0.getHeader());
 40: assertEquals(8, emblStreamSequence0.getOtherCount());
 41: assertEquals(1, emblStreamSequence0.getCCount());
 42: assertEquals(10, emblStreamSequence0.length());
 43: assertEquals(0, emblStreamSequence0.getGCount());
 44: assertEquals(10, rawStreamSequence0.length());
 45: assertEquals(8, rawStreamSequence0.getOtherCount());
 46: assertEquals(1, rawStreamSequence0.getTCount());
 47: assertEquals(1, rawStreamSequence0.getCCount());
 48: assertEquals(0, rawStreamSequence0.getGCount());
 49: assertEquals(3, rawStreamSequence0.getFormatType());
 50: assertEquals(0, rawStreamSequence0.getACount());
 51: assertNotNull(bases0);
 52: 
 53: Strand strand0 = bases0.getForwardStrand();
 54: assertEquals((-5), Bases.MIN_PRIORITY);
 55: assertEquals(0, Bases.MEDIUM_PRIORITY);
 56: assertEquals(2, Bases.REVERSE);
 57: assertEquals(1, Bases.FORWARD);
 58: assertEquals(5, Bases.MAX_PRIORITY);
 59: assertEquals(1, Strand.FORWARD);
 60: assertEquals(2, Strand.REVERSE);
 61: assertEquals(0, emblStreamSequence0.getACount());
 62: assertEquals(1, emblStreamSequence0.getFormatType());
 63: assertEquals(1, emblStreamSequence0.getTCount());
 64: assertNull(emblStreamSequence0.getHeader());
 65: assertEquals(8, emblStreamSequence0.getOtherCount());
 66: assertEquals(1, emblStreamSequence0.getCCount());
 67: assertEquals(10, emblStreamSequence0.length());
 68: assertEquals(0, emblStreamSequence0.getGCount());
 69: assertEquals(10, rawStreamSequence0.length());
 70: assertEquals(8, rawStreamSequence0.getOtherCount());
 71: assertEquals(1, rawStreamSequence0.getTCount());
 72: assertEquals(1, rawStreamSequence0.getCCount());
 73: assertEquals(0, rawStreamSequence0.getGCount());
 74: assertEquals(3, rawStreamSequence0.getFormatType());
 75: assertEquals(0, rawStreamSequence0.getACount());
 76: assertEquals(1, strand0.getDirection());
 77: assertTrue(strand0.isForwardStrand());
 78: assertNotNull(strand0);
 79: 
 80: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 81: assertEquals((-5), Bases.MIN_PRIORITY);
 82: assertEquals(0, Bases.MEDIUM_PRIORITY);
 83: assertEquals(2, Bases.REVERSE);
 84: assertEquals(1, Bases.FORWARD);
 85: assertEquals(5, Bases.MAX_PRIORITY);
 86: assertEquals(1, Strand.FORWARD);
 87: assertEquals(2, Strand.REVERSE);
 88: assertEquals(0, emblStreamSequence0.getACount());
 89: assertEquals(1, emblStreamSequence0.getFormatType());
 90: assertEquals(1, emblStreamSequence0.getTCount());
 91: assertNull(emblStreamSequence0.getHeader());
 92: assertEquals(8, emblStreamSequence0.getOtherCount());
 93: assertEquals(1, emblStreamSequence0.getCCount());
 94: assertEquals(10, emblStreamSequence0.length());
 95: assertEquals(0, emblStreamSequence0.getGCount());
 96: assertEquals(10, rawStreamSequence0.length());
 97: assertEquals(8, rawStreamSequence0.getOtherCount());
 98: assertEquals(1, rawStreamSequence0.getTCount());
 99: assertEquals(1, rawStreamSequence0.getCCount());
100: assertEquals(0, rawStreamSequence0.getGCount());
101: assertEquals(3, rawStreamSequence0.getFormatType());
102: assertEquals(0, rawStreamSequence0.getACount());
103: assertEquals(1, strand0.getDirection());
104: assertTrue(strand0.isForwardStrand());
105: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
106: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
107: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
108: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
109: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
110: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
111: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
112: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
113: assertNotNull(cumulativeGCSkewAlgorithm0);
114: 
115: Float float0 = cumulativeGCSkewAlgorithm0.getAverage();
116: assertEquals((-1.0F), (float)float0, 0.01F);
117: assertEquals((-5), Bases.MIN_PRIORITY);
118: assertEquals(0, Bases.MEDIUM_PRIORITY);
119: assertEquals(2, Bases.REVERSE);
120: assertEquals(1, Bases.FORWARD);
121: assertEquals(5, Bases.MAX_PRIORITY);
122: assertEquals(1, Strand.FORWARD);
123: assertEquals(2, Strand.REVERSE);
124: assertEquals(0, emblStreamSequence0.getACount());
125: assertEquals(1, emblStreamSequence0.getFormatType());
126: assertEquals(1, emblStreamSequence0.getTCount());
127: assertNull(emblStreamSequence0.getHeader());
128: assertEquals(8, emblStreamSequence0.getOtherCount());
129: assertEquals(1, emblStreamSequence0.getCCount());
130: assertEquals(10, emblStreamSequence0.length());
131: assertEquals(0, emblStreamSequence0.getGCount());
132: assertEquals(10, rawStreamSequence0.length());
133: assertEquals(8, rawStreamSequence0.getOtherCount());
134: assertEquals(1, rawStreamSequence0.getTCount());
135: assertEquals(1, rawStreamSequence0.getCCount());
136: assertEquals(0, rawStreamSequence0.getGCount());
137: assertEquals(3, rawStreamSequence0.getFormatType());
138: assertEquals(0, rawStreamSequence0.getACount());
139: assertEquals(1, strand0.getDirection());
140: assertTrue(strand0.isForwardStrand());
141: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
142: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
143: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
144: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
145: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
146: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
147: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
148: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
149: assertNotNull(float0);

Test case 14

  1: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm((Strand) null);

Test case 15

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("K.?zfgN~e");
  2: assertEquals(9, genbankStreamSequence0.length());
  3: assertEquals(1, genbankStreamSequence0.getGCount());
  4: assertEquals(0, genbankStreamSequence0.getACount());
  5: assertEquals(0, genbankStreamSequence0.getTCount());
  6: assertEquals(8, genbankStreamSequence0.getOtherCount());
  7: assertEquals(2, genbankStreamSequence0.getFormatType());
  8: assertNull(genbankStreamSequence0.getHeader());
  9: assertEquals(0, genbankStreamSequence0.getCCount());
 10: assertNotNull(genbankStreamSequence0);
 11: 
 12: Bases bases0 = new Bases(genbankStreamSequence0);
 13: assertEquals(5, Bases.MAX_PRIORITY);
 14: assertEquals(2, Bases.REVERSE);
 15: assertEquals(0, Bases.MEDIUM_PRIORITY);
 16: assertEquals(1, Bases.FORWARD);
 17: assertEquals((-5), Bases.MIN_PRIORITY);
 18: assertEquals(9, genbankStreamSequence0.length());
 19: assertEquals(1, genbankStreamSequence0.getGCount());
 20: assertEquals(0, genbankStreamSequence0.getACount());
 21: assertEquals(0, genbankStreamSequence0.getTCount());
 22: assertEquals(8, genbankStreamSequence0.getOtherCount());
 23: assertEquals(2, genbankStreamSequence0.getFormatType());
 24: assertNull(genbankStreamSequence0.getHeader());
 25: assertEquals(0, genbankStreamSequence0.getCCount());
 26: assertNotNull(bases0);
 27: 
 28: Strand strand0 = bases0.getForwardStrand();
 29: assertEquals(5, Bases.MAX_PRIORITY);
 30: assertEquals(2, Bases.REVERSE);
 31: assertEquals(0, Bases.MEDIUM_PRIORITY);
 32: assertEquals(1, Bases.FORWARD);
 33: assertEquals((-5), Bases.MIN_PRIORITY);
 34: assertEquals(1, Strand.FORWARD);
 35: assertEquals(2, Strand.REVERSE);
 36: assertEquals(9, genbankStreamSequence0.length());
 37: assertEquals(1, genbankStreamSequence0.getGCount());
 38: assertEquals(0, genbankStreamSequence0.getACount());
 39: assertEquals(0, genbankStreamSequence0.getTCount());
 40: assertEquals(8, genbankStreamSequence0.getOtherCount());
 41: assertEquals(2, genbankStreamSequence0.getFormatType());
 42: assertNull(genbankStreamSequence0.getHeader());
 43: assertEquals(0, genbankStreamSequence0.getCCount());
 44: assertEquals(1, strand0.getDirection());
 45: assertTrue(strand0.isForwardStrand());
 46: assertNotNull(strand0);
 47: 
 48: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 49: assertEquals(5, Bases.MAX_PRIORITY);
 50: assertEquals(2, Bases.REVERSE);
 51: assertEquals(0, Bases.MEDIUM_PRIORITY);
 52: assertEquals(1, Bases.FORWARD);
 53: assertEquals((-5), Bases.MIN_PRIORITY);
 54: assertEquals(1, Strand.FORWARD);
 55: assertEquals(2, Strand.REVERSE);
 56: assertEquals(9, genbankStreamSequence0.length());
 57: assertEquals(1, genbankStreamSequence0.getGCount());
 58: assertEquals(0, genbankStreamSequence0.getACount());
 59: assertEquals(0, genbankStreamSequence0.getTCount());
 60: assertEquals(8, genbankStreamSequence0.getOtherCount());
 61: assertEquals(2, genbankStreamSequence0.getFormatType());
 62: assertNull(genbankStreamSequence0.getHeader());
 63: assertEquals(0, genbankStreamSequence0.getCCount());
 64: assertEquals(1, strand0.getDirection());
 65: assertTrue(strand0.isForwardStrand());
 66: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 67: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 68: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 69: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 70: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 71: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 72: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 73: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 74: assertNotNull(cumulativeGCSkewAlgorithm0);
 75: 
 76: float[] floatArray0 = new float[5];
 77: cumulativeGCSkewAlgorithm0.getValues(4112, 2, floatArray0);

Test case 16

  1: char[] charArray0 = new char[3];
  2: Short short0 = new Short((short)341);
  3: assertEquals((short)341, (short)short0);
  4: assertNotNull(short0);
  5: 
  6: Integer integer0 = JLayeredPane.MODAL_LAYER;
  7: assertEquals(200, (int)integer0);
  8: assertNotNull(integer0);
  9: 
 10: PartialSequence partialSequence0 = new PartialSequence(charArray0, (-604), (-2856), short0, integer0);
 11: assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
 12: assertEquals(0, partialSequence0.getGCount());
 13: assertEquals(0, partialSequence0.getTCount());
 14: assertEquals(0, partialSequence0.getCCount());
 15: assertEquals((-604), partialSequence0.length());
 16: assertFalse(partialSequence0.isComplement());
 17: assertEquals(0, partialSequence0.getACount());
 18: assertEquals(200, (int)partialSequence0.getPhase());
 19: assertEquals(3, partialSequence0.getOtherCount());
 20: assertEquals((short)341, (short)partialSequence0.getStrand());
 21: assertNotNull(partialSequence0);
 22: 
 23: Bases bases0 = new Bases(partialSequence0);
 24: assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
 25: assertEquals(0, Bases.MEDIUM_PRIORITY);
 26: assertEquals((-5), Bases.MIN_PRIORITY);
 27: assertEquals(5, Bases.MAX_PRIORITY);
 28: assertEquals(2, Bases.REVERSE);
 29: assertEquals(1, Bases.FORWARD);
 30: assertEquals(0, partialSequence0.getGCount());
 31: assertEquals(0, partialSequence0.getTCount());
 32: assertEquals(0, partialSequence0.getCCount());
 33: assertEquals((-604), partialSequence0.length());
 34: assertFalse(partialSequence0.isComplement());
 35: assertEquals(0, partialSequence0.getACount());
 36: assertEquals(200, (int)partialSequence0.getPhase());
 37: assertEquals(3, partialSequence0.getOtherCount());
 38: assertEquals((short)341, (short)partialSequence0.getStrand());
 39: assertNotNull(bases0);
 40: 
 41: Strand strand0 = bases0.getForwardStrand();
 42: assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
 43: assertEquals(0, Bases.MEDIUM_PRIORITY);
 44: assertEquals((-5), Bases.MIN_PRIORITY);
 45: assertEquals(5, Bases.MAX_PRIORITY);
 46: assertEquals(2, Bases.REVERSE);
 47: assertEquals(1, Bases.FORWARD);
 48: assertEquals(1, Strand.FORWARD);
 49: assertEquals(2, Strand.REVERSE);
 50: assertEquals(0, partialSequence0.getGCount());
 51: assertEquals(0, partialSequence0.getTCount());
 52: assertEquals(0, partialSequence0.getCCount());
 53: assertEquals((-604), partialSequence0.length());
 54: assertFalse(partialSequence0.isComplement());
 55: assertEquals(0, partialSequence0.getACount());
 56: assertEquals(200, (int)partialSequence0.getPhase());
 57: assertEquals(3, partialSequence0.getOtherCount());
 58: assertEquals((short)341, (short)partialSequence0.getStrand());
 59: assertEquals(1, strand0.getDirection());
 60: assertTrue(strand0.isForwardStrand());
 61: assertNotNull(strand0);
 62: 
 63: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 64: assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
 65: assertEquals(0, Bases.MEDIUM_PRIORITY);
 66: assertEquals((-5), Bases.MIN_PRIORITY);
 67: assertEquals(5, Bases.MAX_PRIORITY);
 68: assertEquals(2, Bases.REVERSE);
 69: assertEquals(1, Bases.FORWARD);
 70: assertEquals(1, Strand.FORWARD);
 71: assertEquals(2, Strand.REVERSE);
 72: assertEquals(0, partialSequence0.getGCount());
 73: assertEquals(0, partialSequence0.getTCount());
 74: assertEquals(0, partialSequence0.getCCount());
 75: assertEquals((-604), partialSequence0.length());
 76: assertFalse(partialSequence0.isComplement());
 77: assertEquals(0, partialSequence0.getACount());
 78: assertEquals(200, (int)partialSequence0.getPhase());
 79: assertEquals(3, partialSequence0.getOtherCount());
 80: assertEquals((short)341, (short)partialSequence0.getStrand());
 81: assertEquals(1, strand0.getDirection());
 82: assertTrue(strand0.isForwardStrand());
 83: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 84: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 85: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 86: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 87: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 88: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 89: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 90: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 91: assertNotNull(cumulativeGCSkewAlgorithm0);
 92: 
 93: float[] floatArray0 = new float[9];
 94: cumulativeGCSkewAlgorithm0.getValues(0, 341, floatArray0);

Test case 17

  1: BioJavaSequence bioJavaSequence0 = new BioJavaSequence((SymbolList) null);
  2: assertNotNull(bioJavaSequence0);
  3: 
  4: Bases bases0 = new Bases(bioJavaSequence0);
  5: assertEquals(1, Bases.FORWARD);
  6: assertEquals(2, Bases.REVERSE);
  7: assertEquals(5, Bases.MAX_PRIORITY);
  8: assertEquals((-5), Bases.MIN_PRIORITY);
  9: assertEquals(0, Bases.MEDIUM_PRIORITY);
 10: assertNotNull(bases0);
 11: 
 12: Strand strand0 = bases0.getForwardStrand();
 13: assertEquals(1, Bases.FORWARD);
 14: assertEquals(2, Bases.REVERSE);
 15: assertEquals(5, Bases.MAX_PRIORITY);
 16: assertEquals((-5), Bases.MIN_PRIORITY);
 17: assertEquals(0, Bases.MEDIUM_PRIORITY);
 18: assertEquals(1, Strand.FORWARD);
 19: assertEquals(2, Strand.REVERSE);
 20: assertEquals(1, strand0.getDirection());
 21: assertTrue(strand0.isForwardStrand());
 22: assertNotNull(strand0);
 23: 
 24: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 25: assertEquals(1, Bases.FORWARD);
 26: assertEquals(2, Bases.REVERSE);
 27: assertEquals(5, Bases.MAX_PRIORITY);
 28: assertEquals((-5), Bases.MIN_PRIORITY);
 29: assertEquals(0, Bases.MEDIUM_PRIORITY);
 30: assertEquals(1, Strand.FORWARD);
 31: assertEquals(2, Strand.REVERSE);
 32: assertEquals(1, strand0.getDirection());
 33: assertTrue(strand0.isForwardStrand());
 34: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 35: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 36: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 37: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 38: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 39: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 40: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 41: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 42: assertNotNull(cumulativeGCSkewAlgorithm0);
 43: 
 44: float[] floatArray0 = new float[5];
 45: cumulativeGCSkewAlgorithm0.getValues(5, 169, floatArray0);

Test case 18

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("K.?zfgN~e");
  2: assertEquals(8, genbankStreamSequence0.getOtherCount());
  3: assertNull(genbankStreamSequence0.getHeader());
  4: assertEquals(0, genbankStreamSequence0.getCCount());
  5: assertEquals(9, genbankStreamSequence0.length());
  6: assertEquals(1, genbankStreamSequence0.getGCount());
  7: assertEquals(0, genbankStreamSequence0.getACount());
  8: assertEquals(2, genbankStreamSequence0.getFormatType());
  9: assertEquals(0, genbankStreamSequence0.getTCount());
 10: assertNotNull(genbankStreamSequence0);
 11: 
 12: Bases bases0 = new Bases(genbankStreamSequence0);
 13: assertEquals(1, Bases.FORWARD);
 14: assertEquals((-5), Bases.MIN_PRIORITY);
 15: assertEquals(0, Bases.MEDIUM_PRIORITY);
 16: assertEquals(2, Bases.REVERSE);
 17: assertEquals(5, Bases.MAX_PRIORITY);
 18: assertEquals(8, genbankStreamSequence0.getOtherCount());
 19: assertNull(genbankStreamSequence0.getHeader());
 20: assertEquals(0, genbankStreamSequence0.getCCount());
 21: assertEquals(9, genbankStreamSequence0.length());
 22: assertEquals(1, genbankStreamSequence0.getGCount());
 23: assertEquals(0, genbankStreamSequence0.getACount());
 24: assertEquals(2, genbankStreamSequence0.getFormatType());
 25: assertEquals(0, genbankStreamSequence0.getTCount());
 26: assertNotNull(bases0);
 27: 
 28: Strand strand0 = bases0.getForwardStrand();
 29: assertEquals(1, Bases.FORWARD);
 30: assertEquals((-5), Bases.MIN_PRIORITY);
 31: assertEquals(0, Bases.MEDIUM_PRIORITY);
 32: assertEquals(2, Bases.REVERSE);
 33: assertEquals(5, Bases.MAX_PRIORITY);
 34: assertEquals(1, Strand.FORWARD);
 35: assertEquals(2, Strand.REVERSE);
 36: assertEquals(8, genbankStreamSequence0.getOtherCount());
 37: assertNull(genbankStreamSequence0.getHeader());
 38: assertEquals(0, genbankStreamSequence0.getCCount());
 39: assertEquals(9, genbankStreamSequence0.length());
 40: assertEquals(1, genbankStreamSequence0.getGCount());
 41: assertEquals(0, genbankStreamSequence0.getACount());
 42: assertEquals(2, genbankStreamSequence0.getFormatType());
 43: assertEquals(0, genbankStreamSequence0.getTCount());
 44: assertTrue(strand0.isForwardStrand());
 45: assertEquals(1, strand0.getDirection());
 46: assertNotNull(strand0);
 47: 
 48: CumulativeGCSkewAlgorithm cumulativeGCSkewAlgorithm0 = new CumulativeGCSkewAlgorithm(strand0);
 49: assertEquals(1, Bases.FORWARD);
 50: assertEquals((-5), Bases.MIN_PRIORITY);
 51: assertEquals(0, Bases.MEDIUM_PRIORITY);
 52: assertEquals(2, Bases.REVERSE);
 53: assertEquals(5, Bases.MAX_PRIORITY);
 54: assertEquals(1, Strand.FORWARD);
 55: assertEquals(2, Strand.REVERSE);
 56: assertEquals(8, genbankStreamSequence0.getOtherCount());
 57: assertNull(genbankStreamSequence0.getHeader());
 58: assertEquals(0, genbankStreamSequence0.getCCount());
 59: assertEquals(9, genbankStreamSequence0.length());
 60: assertEquals(1, genbankStreamSequence0.getGCount());
 61: assertEquals(0, genbankStreamSequence0.getACount());
 62: assertEquals(2, genbankStreamSequence0.getFormatType());
 63: assertEquals(0, genbankStreamSequence0.getTCount());
 64: assertTrue(strand0.isForwardStrand());
 65: assertEquals(1, strand0.getDirection());
 66: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 67: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 68: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 69: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 70: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
 71: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
 72: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
 73: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
 74: assertNotNull(cumulativeGCSkewAlgorithm0);
 75: 
 76: Float float0 = cumulativeGCSkewAlgorithm0.getAverage();
 77: assertEquals(1.0F, (float)float0, 0.01F);
 78: assertEquals(1, Bases.FORWARD);
 79: assertEquals((-5), Bases.MIN_PRIORITY);
 80: assertEquals(0, Bases.MEDIUM_PRIORITY);
 81: assertEquals(2, Bases.REVERSE);
 82: assertEquals(5, Bases.MAX_PRIORITY);
 83: assertEquals(1, Strand.FORWARD);
 84: assertEquals(2, Strand.REVERSE);
 85: assertEquals(8, genbankStreamSequence0.getOtherCount());
 86: assertNull(genbankStreamSequence0.getHeader());
 87: assertEquals(0, genbankStreamSequence0.getCCount());
 88: assertEquals(9, genbankStreamSequence0.length());
 89: assertEquals(1, genbankStreamSequence0.getGCount());
 90: assertEquals(0, genbankStreamSequence0.getACount());
 91: assertEquals(2, genbankStreamSequence0.getFormatType());
 92: assertEquals(0, genbankStreamSequence0.getTCount());
 93: assertTrue(strand0.isForwardStrand());
 94: assertEquals(1, strand0.getDirection());
 95: assertFalse(cumulativeGCSkewAlgorithm0.isUserMaxMin());
 96: assertEquals(1.4E-45F, cumulativeGCSkewAlgorithm0.getUserMin(), 0.01F);
 97: assertTrue(cumulativeGCSkewAlgorithm0.scalingFlag());
 98: assertEquals(1, cumulativeGCSkewAlgorithm0.getValueCount());
 99: assertFalse(cumulativeGCSkewAlgorithm0.isRevCompDisplay());
100: assertEquals(3.4028235E38F, cumulativeGCSkewAlgorithm0.getUserMax(), 0.01F);
101: assertEquals("Cumulative GC Skew, (G-C)/(G+C)", cumulativeGCSkewAlgorithm0.getAlgorithmName());
102: assertEquals("gc_skew", cumulativeGCSkewAlgorithm0.getAlgorithmShortName());
103: assertNotNull(float0);

Source Code

  1: No source found for uk.ac.sanger.artemis.plot.CumulativeGCSkewAlgorithm

EvoSuite Parameters

  • TARGET_CLASS: uk.ac.sanger.artemis.plot.CumulativeGCSkewAlgorithm
  • Size: 18
  • Length: 99
  • criterion: LINE;BRANCH;EXCEPTION;WEAKMUTATION;OUTPUT;METHOD;METHODNOEXCEPTION;CBRANCH
  • Coverage: 0.8348857978792189
  • BranchCoverage: 0.75
  • MethodCoverage: 1.0
  • OutputCoverage: 0.4189189189189189


Back to Overview