Summary

Test suite

Test case 1

  1: Bases bases0 = new Bases((Sequence) null);
  2: Strand strand0 = bases0.getForwardStrand();
  3: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
  4: aTDeviationAlgorithm0.getAverage();

Test case 2

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("Scaled Chi Square");
  2: Bases bases0 = new Bases(emblStreamSequence0);
  3: Strand strand0 = bases0.getReverseStrand();
  4: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
  5: Float float0 = aTDeviationAlgorithm0.getMinimumInternal();
  6: assertEquals((-1.0F), (float)float0, 0.01F);
  7: assertTrue(aTDeviationAlgorithm0.scalingFlag());

Test case 3

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("Scaled Chi Square");
  2: Bases bases0 = new Bases(emblStreamSequence0);
  3: Strand strand0 = bases0.getReverseStrand();
  4: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
  5: int int0 = aTDeviationAlgorithm0.getValueCount();
  6: assertEquals(1, int0);
  7: assertTrue(aTDeviationAlgorithm0.scalingFlag());

Test case 4

  1: Bases bases0 = new Bases((Sequence) null);
  2: Strand strand0 = bases0.getReverseStrand();
  3: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
  4: Float float0 = aTDeviationAlgorithm0.getMaximumInternal();
  5: assertTrue(aTDeviationAlgorithm0.scalingFlag());
  6: assertEquals(1.0F, (float)float0, 0.01F);

Test case 5

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("Y+dP9ZU-7#e[");
  2: Bases bases0 = new Bases(genbankStreamSequence0);
  3: Strand strand0 = bases0.getReverseStrand();
  4: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
  5: float[] floatArray0 = new float[8];
  6: aTDeviationAlgorithm0.getValues(592, 1197, floatArray0);
  7: assertArrayEquals(new float[] {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F}, floatArray0, 0.01F);
  8: assertTrue(aTDeviationAlgorithm0.scalingFlag());

Test case 6

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("Scaled Chi Square");
  2: Bases bases0 = new Bases(emblStreamSequence0);
  3: Strand strand0 = bases0.getReverseStrand();
  4: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
  5: float[] floatArray0 = new float[2];
  6: aTDeviationAlgorithm0.getValues(1, 1333, floatArray0);
  7: assertArrayEquals(new float[] {(-0.33333334F), 0.0F}, floatArray0, 0.01F);
  8: assertTrue(aTDeviationAlgorithm0.scalingFlag());

Test case 7

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

Test case 8

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

Test case 9

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

Test case 10

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

Test case 11

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

Test case 12

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

Test case 13

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("Y+dP9ZU-7#e[");
  2: assertNotNull(genbankStreamSequence0);
  3: assertEquals(0, genbankStreamSequence0.getACount());
  4: assertNull(genbankStreamSequence0.getHeader());
  5: assertEquals(0, genbankStreamSequence0.getTCount());
  6: assertEquals(0, genbankStreamSequence0.getCCount());
  7: assertEquals(2, genbankStreamSequence0.getFormatType());
  8: assertEquals(0, genbankStreamSequence0.getGCount());
  9: assertEquals(12, genbankStreamSequence0.length());
 10: assertEquals(12, genbankStreamSequence0.getOtherCount());
 11: 
 12: Bases bases0 = new Bases(genbankStreamSequence0);
 13: assertNotNull(bases0);
 14: assertEquals(2, Bases.REVERSE);
 15: assertEquals(1, Bases.FORWARD);
 16: assertEquals((-5), Bases.MIN_PRIORITY);
 17: assertEquals(0, Bases.MEDIUM_PRIORITY);
 18: assertEquals(5, Bases.MAX_PRIORITY);
 19: assertEquals(0, genbankStreamSequence0.getACount());
 20: assertNull(genbankStreamSequence0.getHeader());
 21: assertEquals(0, genbankStreamSequence0.getTCount());
 22: assertEquals(0, genbankStreamSequence0.getCCount());
 23: assertEquals(2, genbankStreamSequence0.getFormatType());
 24: assertEquals(0, genbankStreamSequence0.getGCount());
 25: assertEquals(12, genbankStreamSequence0.length());
 26: assertEquals(12, genbankStreamSequence0.getOtherCount());
 27: 
 28: Strand strand0 = bases0.getReverseStrand();
 29: assertNotNull(strand0);
 30: assertEquals(2, Bases.REVERSE);
 31: assertEquals(1, Bases.FORWARD);
 32: assertEquals((-5), Bases.MIN_PRIORITY);
 33: assertEquals(0, Bases.MEDIUM_PRIORITY);
 34: assertEquals(5, Bases.MAX_PRIORITY);
 35: assertEquals(2, Strand.REVERSE);
 36: assertEquals(1, Strand.FORWARD);
 37: assertEquals(0, genbankStreamSequence0.getACount());
 38: assertNull(genbankStreamSequence0.getHeader());
 39: assertEquals(0, genbankStreamSequence0.getTCount());
 40: assertEquals(0, genbankStreamSequence0.getCCount());
 41: assertEquals(2, genbankStreamSequence0.getFormatType());
 42: assertEquals(0, genbankStreamSequence0.getGCount());
 43: assertEquals(12, genbankStreamSequence0.length());
 44: assertEquals(12, genbankStreamSequence0.getOtherCount());
 45: assertEquals(2, strand0.getDirection());
 46: assertFalse(strand0.isForwardStrand());
 47: 
 48: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
 49: assertNotNull(aTDeviationAlgorithm0);
 50: assertEquals(2, Bases.REVERSE);
 51: assertEquals(1, Bases.FORWARD);
 52: assertEquals((-5), Bases.MIN_PRIORITY);
 53: assertEquals(0, Bases.MEDIUM_PRIORITY);
 54: assertEquals(5, Bases.MAX_PRIORITY);
 55: assertEquals(2, Strand.REVERSE);
 56: assertEquals(1, Strand.FORWARD);
 57: assertEquals(0, genbankStreamSequence0.getACount());
 58: assertNull(genbankStreamSequence0.getHeader());
 59: assertEquals(0, genbankStreamSequence0.getTCount());
 60: assertEquals(0, genbankStreamSequence0.getCCount());
 61: assertEquals(2, genbankStreamSequence0.getFormatType());
 62: assertEquals(0, genbankStreamSequence0.getGCount());
 63: assertEquals(12, genbankStreamSequence0.length());
 64: assertEquals(12, genbankStreamSequence0.getOtherCount());
 65: assertEquals(2, strand0.getDirection());
 66: assertFalse(strand0.isForwardStrand());
 67: assertEquals("at_deviation", aTDeviationAlgorithm0.getAlgorithmShortName());
 68: assertEquals("AT Deviation (A-T)/(A+T)", aTDeviationAlgorithm0.getAlgorithmName());
 69: assertTrue(aTDeviationAlgorithm0.scalingFlag());
 70: assertEquals(3.4028235E38F, aTDeviationAlgorithm0.getUserMax(), 0.01F);
 71: assertEquals(1, aTDeviationAlgorithm0.getValueCount());
 72: assertFalse(aTDeviationAlgorithm0.isRevCompDisplay());
 73: assertEquals(1.4E-45F, aTDeviationAlgorithm0.getUserMin(), 0.01F);
 74: assertFalse(aTDeviationAlgorithm0.isUserMaxMin());
 75: 
 76: genbankStreamSequence0.setFromChar(bases0.letter_index);
 77: assertEquals(2, Bases.REVERSE);
 78: assertEquals(1, Bases.FORWARD);
 79: assertEquals((-5), Bases.MIN_PRIORITY);
 80: assertEquals(0, Bases.MEDIUM_PRIORITY);
 81: assertEquals(5, Bases.MAX_PRIORITY);
 82: assertEquals(5, genbankStreamSequence0.length());
 83: assertEquals(1, genbankStreamSequence0.getTCount());
 84: assertEquals(1, genbankStreamSequence0.getACount());
 85: assertEquals(1, genbankStreamSequence0.getOtherCount());
 86: assertNull(genbankStreamSequence0.getHeader());
 87: assertEquals(1, genbankStreamSequence0.getGCount());
 88: assertEquals(1, genbankStreamSequence0.getCCount());
 89: assertEquals(2, genbankStreamSequence0.getFormatType());
 90: 
 91: Float float0 = aTDeviationAlgorithm0.getAverage();
 92: assertNotNull(float0);
 93: assertEquals(2, Bases.REVERSE);
 94: assertEquals(1, Bases.FORWARD);
 95: assertEquals((-5), Bases.MIN_PRIORITY);
 96: assertEquals(0, Bases.MEDIUM_PRIORITY);
 97: assertEquals(5, Bases.MAX_PRIORITY);
 98: assertEquals(2, Strand.REVERSE);
 99: assertEquals(1, Strand.FORWARD);
100: assertEquals(5, genbankStreamSequence0.length());
101: assertEquals(1, genbankStreamSequence0.getTCount());
102: assertEquals(1, genbankStreamSequence0.getACount());
103: assertEquals(1, genbankStreamSequence0.getOtherCount());
104: assertNull(genbankStreamSequence0.getHeader());
105: assertEquals(1, genbankStreamSequence0.getGCount());
106: assertEquals(1, genbankStreamSequence0.getCCount());
107: assertEquals(2, genbankStreamSequence0.getFormatType());
108: assertEquals(2, strand0.getDirection());
109: assertFalse(strand0.isForwardStrand());
110: assertEquals("at_deviation", aTDeviationAlgorithm0.getAlgorithmShortName());
111: assertEquals("AT Deviation (A-T)/(A+T)", aTDeviationAlgorithm0.getAlgorithmName());
112: assertTrue(aTDeviationAlgorithm0.scalingFlag());
113: assertEquals(3.4028235E38F, aTDeviationAlgorithm0.getUserMax(), 0.01F);
114: assertEquals(1, aTDeviationAlgorithm0.getValueCount());
115: assertFalse(aTDeviationAlgorithm0.isRevCompDisplay());
116: assertEquals(1.4E-45F, aTDeviationAlgorithm0.getUserMin(), 0.01F);
117: assertFalse(aTDeviationAlgorithm0.isUserMaxMin());
118: assertEquals(0.0F, (float)float0, 0.01F);

Test case 14

  1: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm((Strand) null);

Test case 15

  1: Bases bases0 = new Bases((Sequence) null);
  2: assertNotNull(bases0);
  3: assertEquals((-5), Bases.MIN_PRIORITY);
  4: assertEquals(0, Bases.MEDIUM_PRIORITY);
  5: assertEquals(2, Bases.REVERSE);
  6: assertEquals(1, Bases.FORWARD);
  7: assertEquals(5, Bases.MAX_PRIORITY);
  8: 
  9: Strand strand0 = bases0.getReverseStrand();
 10: assertNotNull(strand0);
 11: assertEquals((-5), Bases.MIN_PRIORITY);
 12: assertEquals(0, Bases.MEDIUM_PRIORITY);
 13: assertEquals(2, Bases.REVERSE);
 14: assertEquals(1, Bases.FORWARD);
 15: assertEquals(5, Bases.MAX_PRIORITY);
 16: assertEquals(2, Strand.REVERSE);
 17: assertEquals(1, Strand.FORWARD);
 18: assertFalse(strand0.isForwardStrand());
 19: assertEquals(2, strand0.getDirection());
 20: 
 21: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
 22: assertNotNull(aTDeviationAlgorithm0);
 23: assertEquals((-5), Bases.MIN_PRIORITY);
 24: assertEquals(0, Bases.MEDIUM_PRIORITY);
 25: assertEquals(2, Bases.REVERSE);
 26: assertEquals(1, Bases.FORWARD);
 27: assertEquals(5, Bases.MAX_PRIORITY);
 28: assertEquals(2, Strand.REVERSE);
 29: assertEquals(1, Strand.FORWARD);
 30: assertFalse(strand0.isForwardStrand());
 31: assertEquals(2, strand0.getDirection());
 32: assertEquals("at_deviation", aTDeviationAlgorithm0.getAlgorithmShortName());
 33: assertEquals(1.4E-45F, aTDeviationAlgorithm0.getUserMin(), 0.01F);
 34: assertEquals("AT Deviation (A-T)/(A+T)", aTDeviationAlgorithm0.getAlgorithmName());
 35: assertTrue(aTDeviationAlgorithm0.scalingFlag());
 36: assertEquals(1, aTDeviationAlgorithm0.getValueCount());
 37: assertEquals(3.4028235E38F, aTDeviationAlgorithm0.getUserMax(), 0.01F);
 38: assertFalse(aTDeviationAlgorithm0.isRevCompDisplay());
 39: assertFalse(aTDeviationAlgorithm0.isUserMaxMin());
 40: 
 41: float[] floatArray0 = new float[8];
 42: aTDeviationAlgorithm0.getValues(2, 1, floatArray0);

Test case 16

  1: Bases bases0 = new Bases((Sequence) null);
  2: assertNotNull(bases0);
  3: assertEquals((-5), Bases.MIN_PRIORITY);
  4: assertEquals(0, Bases.MEDIUM_PRIORITY);
  5: assertEquals(5, Bases.MAX_PRIORITY);
  6: assertEquals(1, Bases.FORWARD);
  7: assertEquals(2, Bases.REVERSE);
  8: 
  9: Strand strand0 = bases0.getForwardStrand();
 10: assertNotNull(strand0);
 11: assertEquals((-5), Bases.MIN_PRIORITY);
 12: assertEquals(0, Bases.MEDIUM_PRIORITY);
 13: assertEquals(5, Bases.MAX_PRIORITY);
 14: assertEquals(1, Bases.FORWARD);
 15: assertEquals(2, Bases.REVERSE);
 16: assertEquals(1, Strand.FORWARD);
 17: assertEquals(2, Strand.REVERSE);
 18: assertEquals(1, strand0.getDirection());
 19: assertTrue(strand0.isForwardStrand());
 20: 
 21: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
 22: assertNotNull(aTDeviationAlgorithm0);
 23: assertEquals((-5), Bases.MIN_PRIORITY);
 24: assertEquals(0, Bases.MEDIUM_PRIORITY);
 25: assertEquals(5, Bases.MAX_PRIORITY);
 26: assertEquals(1, Bases.FORWARD);
 27: assertEquals(2, Bases.REVERSE);
 28: assertEquals(1, Strand.FORWARD);
 29: assertEquals(2, Strand.REVERSE);
 30: assertEquals(1, strand0.getDirection());
 31: assertTrue(strand0.isForwardStrand());
 32: assertEquals(3.4028235E38F, aTDeviationAlgorithm0.getUserMax(), 0.01F);
 33: assertEquals(1, aTDeviationAlgorithm0.getValueCount());
 34: assertEquals(1.4E-45F, aTDeviationAlgorithm0.getUserMin(), 0.01F);
 35: assertFalse(aTDeviationAlgorithm0.isUserMaxMin());
 36: assertEquals("AT Deviation (A-T)/(A+T)", aTDeviationAlgorithm0.getAlgorithmName());
 37: assertTrue(aTDeviationAlgorithm0.scalingFlag());
 38: assertEquals("at_deviation", aTDeviationAlgorithm0.getAlgorithmShortName());
 39: assertFalse(aTDeviationAlgorithm0.isRevCompDisplay());
 40: 
 41: aTDeviationAlgorithm0.getValues(1, 2, (float[]) null);

Test case 17

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("Scaled Chi Square");
  2: assertNotNull(emblStreamSequence0);
  3: assertNull(emblStreamSequence0.getHeader());
  4: assertEquals(17, emblStreamSequence0.length());
  5: assertEquals(0, emblStreamSequence0.getTCount());
  6: assertEquals(1, emblStreamSequence0.getFormatType());
  7: assertEquals(2, emblStreamSequence0.getACount());
  8: assertEquals(14, emblStreamSequence0.getOtherCount());
  9: assertEquals(0, emblStreamSequence0.getGCount());
 10: assertEquals(1, emblStreamSequence0.getCCount());
 11: 
 12: Bases bases0 = new Bases(emblStreamSequence0);
 13: assertNotNull(bases0);
 14: assertEquals(2, Bases.REVERSE);
 15: assertEquals(0, Bases.MEDIUM_PRIORITY);
 16: assertEquals(5, Bases.MAX_PRIORITY);
 17: assertEquals(1, Bases.FORWARD);
 18: assertEquals((-5), Bases.MIN_PRIORITY);
 19: assertNull(emblStreamSequence0.getHeader());
 20: assertEquals(17, emblStreamSequence0.length());
 21: assertEquals(0, emblStreamSequence0.getTCount());
 22: assertEquals(1, emblStreamSequence0.getFormatType());
 23: assertEquals(2, emblStreamSequence0.getACount());
 24: assertEquals(14, emblStreamSequence0.getOtherCount());
 25: assertEquals(0, emblStreamSequence0.getGCount());
 26: assertEquals(1, emblStreamSequence0.getCCount());
 27: 
 28: Strand strand0 = bases0.getReverseStrand();
 29: assertNotNull(strand0);
 30: assertEquals(2, Bases.REVERSE);
 31: assertEquals(0, Bases.MEDIUM_PRIORITY);
 32: assertEquals(5, Bases.MAX_PRIORITY);
 33: assertEquals(1, Bases.FORWARD);
 34: assertEquals((-5), Bases.MIN_PRIORITY);
 35: assertEquals(2, Strand.REVERSE);
 36: assertEquals(1, Strand.FORWARD);
 37: assertNull(emblStreamSequence0.getHeader());
 38: assertEquals(17, emblStreamSequence0.length());
 39: assertEquals(0, emblStreamSequence0.getTCount());
 40: assertEquals(1, emblStreamSequence0.getFormatType());
 41: assertEquals(2, emblStreamSequence0.getACount());
 42: assertEquals(14, emblStreamSequence0.getOtherCount());
 43: assertEquals(0, emblStreamSequence0.getGCount());
 44: assertEquals(1, emblStreamSequence0.getCCount());
 45: assertFalse(strand0.isForwardStrand());
 46: assertEquals(2, strand0.getDirection());
 47: 
 48: ATDeviationAlgorithm aTDeviationAlgorithm0 = new ATDeviationAlgorithm(strand0);
 49: assertNotNull(aTDeviationAlgorithm0);
 50: assertEquals(2, Bases.REVERSE);
 51: assertEquals(0, Bases.MEDIUM_PRIORITY);
 52: assertEquals(5, Bases.MAX_PRIORITY);
 53: assertEquals(1, Bases.FORWARD);
 54: assertEquals((-5), Bases.MIN_PRIORITY);
 55: assertEquals(2, Strand.REVERSE);
 56: assertEquals(1, Strand.FORWARD);
 57: assertNull(emblStreamSequence0.getHeader());
 58: assertEquals(17, emblStreamSequence0.length());
 59: assertEquals(0, emblStreamSequence0.getTCount());
 60: assertEquals(1, emblStreamSequence0.getFormatType());
 61: assertEquals(2, emblStreamSequence0.getACount());
 62: assertEquals(14, emblStreamSequence0.getOtherCount());
 63: assertEquals(0, emblStreamSequence0.getGCount());
 64: assertEquals(1, emblStreamSequence0.getCCount());
 65: assertFalse(strand0.isForwardStrand());
 66: assertEquals(2, strand0.getDirection());
 67: assertFalse(aTDeviationAlgorithm0.isRevCompDisplay());
 68: assertEquals(3.4028235E38F, aTDeviationAlgorithm0.getUserMax(), 0.01F);
 69: assertTrue(aTDeviationAlgorithm0.scalingFlag());
 70: assertFalse(aTDeviationAlgorithm0.isUserMaxMin());
 71: assertEquals("AT Deviation (A-T)/(A+T)", aTDeviationAlgorithm0.getAlgorithmName());
 72: assertEquals("at_deviation", aTDeviationAlgorithm0.getAlgorithmShortName());
 73: assertEquals(1.4E-45F, aTDeviationAlgorithm0.getUserMin(), 0.01F);
 74: assertEquals(1, aTDeviationAlgorithm0.getValueCount());
 75: 
 76: Float float0 = aTDeviationAlgorithm0.getAverage();
 77: assertNotNull(float0);
 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: assertNull(emblStreamSequence0.getHeader());
 86: assertEquals(17, emblStreamSequence0.length());
 87: assertEquals(0, emblStreamSequence0.getTCount());
 88: assertEquals(1, emblStreamSequence0.getFormatType());
 89: assertEquals(2, emblStreamSequence0.getACount());
 90: assertEquals(14, emblStreamSequence0.getOtherCount());
 91: assertEquals(0, emblStreamSequence0.getGCount());
 92: assertEquals(1, emblStreamSequence0.getCCount());
 93: assertFalse(strand0.isForwardStrand());
 94: assertEquals(2, strand0.getDirection());
 95: assertFalse(aTDeviationAlgorithm0.isRevCompDisplay());
 96: assertEquals(3.4028235E38F, aTDeviationAlgorithm0.getUserMax(), 0.01F);
 97: assertTrue(aTDeviationAlgorithm0.scalingFlag());
 98: assertFalse(aTDeviationAlgorithm0.isUserMaxMin());
 99: assertEquals("AT Deviation (A-T)/(A+T)", aTDeviationAlgorithm0.getAlgorithmName());
100: assertEquals("at_deviation", aTDeviationAlgorithm0.getAlgorithmShortName());
101: assertEquals(1.4E-45F, aTDeviationAlgorithm0.getUserMin(), 0.01F);
102: assertEquals(1, aTDeviationAlgorithm0.getValueCount());
103: assertEquals((-1.0F), (float)float0, 0.01F);

Source Code

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

EvoSuite Parameters

  • TARGET_CLASS: uk.ac.sanger.artemis.plot.ATDeviationAlgorithm
  • Size: 17
  • Length: 81
  • criterion: LINE;BRANCH;EXCEPTION;WEAKMUTATION;OUTPUT;METHOD;METHODNOEXCEPTION;CBRANCH
  • Coverage: 0.8764785327285327
  • BranchCoverage: 0.8636363636363636
  • MethodCoverage: 1.0
  • OutputCoverage: 0.3783783783783784


Back to Overview