Summary

Test suite

Test case 1

  1: Bases bases0 = new Bases((Sequence) null);
  2: Strand strand0 = bases0.getReverseStrand();
  3: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
  4: aGWindowAlgorithm0.getValueCount();

Test case 2

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("Joz- ^$d](\"INZS+");
  2: Bases bases0 = new Bases(fastaStreamSequence0);
  3: Strand strand0 = bases0.getForwardStrand();
  4: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
  5: Float float0 = aGWindowAlgorithm0.getMaximumInternal();
  6: assertEquals(100.0F, (float)float0, 0.01F);
  7: assertTrue(aGWindowAlgorithm0.scalingFlag());

Test case 3

  1: Short short0 = new Short((short)2953);
  2: Integer integer0 = new Integer(103);
  3: PartialSequence partialSequence0 = new PartialSequence((char[]) null, 0, 0, short0, integer0);
  4: Bases bases0 = new Bases(partialSequence0);
  5: Strand strand0 = bases0.getReverseStrand();
  6: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
  7: Float float0 = aGWindowAlgorithm0.getMinimumInternal();
  8: assertTrue(aGWindowAlgorithm0.scalingFlag());
  9: assertEquals(0.0F, (float)float0, 0.01F);

Test case 4

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("Joz- ^$d](\"INZS+");
  2: Bases bases0 = new Bases(fastaStreamSequence0);
  3: Strand strand0 = bases0.getForwardStrand();
  4: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
  5: aGWindowAlgorithm0.getAverage();
  6: assertTrue(aGWindowAlgorithm0.scalingFlag());

Test case 5

  1: RawStreamSequence rawStreamSequence0 = new RawStreamSequence("Reverse GC Frame Plot");
  2: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence(rawStreamSequence0);
  3: Bases bases0 = new Bases(emblStreamSequence0);
  4: Strand strand0 = bases0.getForwardStrand();
  5: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
  6: float[] floatArray0 = new float[3];
  7: aGWindowAlgorithm0.getValues(2, 3294, floatArray0);
  8: assertArrayEquals(new float[] {0.030367445F, 0.0F, 0.0F}, floatArray0, 0.01F);
  9: assertTrue(aGWindowAlgorithm0.scalingFlag());

Test case 6

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

Test case 7

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

Test case 8

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

Test case 9

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

Test case 10

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

Test case 11

  1: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm((Strand) null);

Test case 12

  1: Bases bases0 = new Bases((Sequence) null);
  2: assertNotNull(bases0);
  3: assertEquals(1, Bases.FORWARD);
  4: assertEquals(0, Bases.MEDIUM_PRIORITY);
  5: assertEquals(5, Bases.MAX_PRIORITY);
  6: assertEquals((-5), Bases.MIN_PRIORITY);
  7: assertEquals(2, Bases.REVERSE);
  8: 
  9: Strand strand0 = bases0.getReverseStrand();
 10: assertEquals(2, strand0.getDirection());
 11: assertFalse(strand0.isForwardStrand());
 12: assertNotNull(strand0);
 13: assertEquals(1, Bases.FORWARD);
 14: assertEquals(0, Bases.MEDIUM_PRIORITY);
 15: assertEquals(5, Bases.MAX_PRIORITY);
 16: assertEquals((-5), Bases.MIN_PRIORITY);
 17: assertEquals(2, Bases.REVERSE);
 18: assertEquals(2, Strand.REVERSE);
 19: assertEquals(1, Strand.FORWARD);
 20: 
 21: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
 22: assertEquals(2, strand0.getDirection());
 23: assertFalse(strand0.isForwardStrand());
 24: assertEquals(1, aGWindowAlgorithm0.getValueCount());
 25: assertEquals("AG Content (%)", aGWindowAlgorithm0.getAlgorithmName());
 26: assertFalse(aGWindowAlgorithm0.isUserMaxMin());
 27: assertEquals(1.4E-45F, aGWindowAlgorithm0.getUserMin(), 0.01F);
 28: assertFalse(aGWindowAlgorithm0.isRevCompDisplay());
 29: assertEquals("ag_content", aGWindowAlgorithm0.getAlgorithmShortName());
 30: assertTrue(aGWindowAlgorithm0.scalingFlag());
 31: assertEquals(3.4028235E38F, aGWindowAlgorithm0.getUserMax(), 0.01F);
 32: assertNotNull(aGWindowAlgorithm0);
 33: assertEquals(1, Bases.FORWARD);
 34: assertEquals(0, Bases.MEDIUM_PRIORITY);
 35: assertEquals(5, Bases.MAX_PRIORITY);
 36: assertEquals((-5), Bases.MIN_PRIORITY);
 37: assertEquals(2, Bases.REVERSE);
 38: assertEquals(2, Strand.REVERSE);
 39: assertEquals(1, Strand.FORWARD);
 40: 
 41: aGWindowAlgorithm0.getAverage();

Test case 13

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

Test case 14

  1: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("}])1@Fg", "m");
  2: assertEquals(0, fastaStreamSequence0.getCCount());
  3: assertEquals(0, fastaStreamSequence0.getTCount());
  4: assertEquals(6, fastaStreamSequence0.getOtherCount());
  5: assertEquals(4, fastaStreamSequence0.getFormatType());
  6: assertEquals(1, fastaStreamSequence0.getGCount());
  7: assertEquals(7, fastaStreamSequence0.length());
  8: assertEquals(0, fastaStreamSequence0.getACount());
  9: assertNotNull(fastaStreamSequence0);
 10: 
 11: Bases bases0 = new Bases(fastaStreamSequence0);
 12: assertEquals(0, fastaStreamSequence0.getCCount());
 13: assertEquals(0, fastaStreamSequence0.getTCount());
 14: assertEquals(6, fastaStreamSequence0.getOtherCount());
 15: assertEquals(4, fastaStreamSequence0.getFormatType());
 16: assertEquals(1, fastaStreamSequence0.getGCount());
 17: assertEquals(7, fastaStreamSequence0.length());
 18: assertEquals(0, fastaStreamSequence0.getACount());
 19: assertNotNull(bases0);
 20: assertEquals(2, Bases.REVERSE);
 21: assertEquals(0, Bases.MEDIUM_PRIORITY);
 22: assertEquals(5, Bases.MAX_PRIORITY);
 23: assertEquals(1, Bases.FORWARD);
 24: assertEquals((-5), Bases.MIN_PRIORITY);
 25: 
 26: Strand strand0 = bases0.getReverseStrand();
 27: assertEquals(0, fastaStreamSequence0.getCCount());
 28: assertEquals(0, fastaStreamSequence0.getTCount());
 29: assertEquals(6, fastaStreamSequence0.getOtherCount());
 30: assertEquals(4, fastaStreamSequence0.getFormatType());
 31: assertEquals(1, fastaStreamSequence0.getGCount());
 32: assertEquals(7, fastaStreamSequence0.length());
 33: assertEquals(0, fastaStreamSequence0.getACount());
 34: assertFalse(strand0.isForwardStrand());
 35: assertEquals(2, strand0.getDirection());
 36: assertNotNull(strand0);
 37: assertEquals(2, Bases.REVERSE);
 38: assertEquals(0, Bases.MEDIUM_PRIORITY);
 39: assertEquals(5, Bases.MAX_PRIORITY);
 40: assertEquals(1, Bases.FORWARD);
 41: assertEquals((-5), Bases.MIN_PRIORITY);
 42: assertEquals(1, Strand.FORWARD);
 43: assertEquals(2, Strand.REVERSE);
 44: 
 45: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
 46: assertEquals(0, fastaStreamSequence0.getCCount());
 47: assertEquals(0, fastaStreamSequence0.getTCount());
 48: assertEquals(6, fastaStreamSequence0.getOtherCount());
 49: assertEquals(4, fastaStreamSequence0.getFormatType());
 50: assertEquals(1, fastaStreamSequence0.getGCount());
 51: assertEquals(7, fastaStreamSequence0.length());
 52: assertEquals(0, fastaStreamSequence0.getACount());
 53: assertFalse(strand0.isForwardStrand());
 54: assertEquals(2, strand0.getDirection());
 55: assertEquals(3.4028235E38F, aGWindowAlgorithm0.getUserMax(), 0.01F);
 56: assertEquals(1.4E-45F, aGWindowAlgorithm0.getUserMin(), 0.01F);
 57: assertFalse(aGWindowAlgorithm0.isUserMaxMin());
 58: assertEquals("ag_content", aGWindowAlgorithm0.getAlgorithmShortName());
 59: assertTrue(aGWindowAlgorithm0.scalingFlag());
 60: assertFalse(aGWindowAlgorithm0.isRevCompDisplay());
 61: assertEquals(1, aGWindowAlgorithm0.getValueCount());
 62: assertEquals("AG Content (%)", aGWindowAlgorithm0.getAlgorithmName());
 63: assertNotNull(aGWindowAlgorithm0);
 64: assertEquals(2, Bases.REVERSE);
 65: assertEquals(0, Bases.MEDIUM_PRIORITY);
 66: assertEquals(5, Bases.MAX_PRIORITY);
 67: assertEquals(1, Bases.FORWARD);
 68: assertEquals((-5), Bases.MIN_PRIORITY);
 69: assertEquals(1, Strand.FORWARD);
 70: assertEquals(2, Strand.REVERSE);
 71: 
 72: float[] floatArray0 = new float[8];
 73: aGWindowAlgorithm0.getValues((-798), 50000, floatArray0);

Test case 15

  1: RawStreamSequence rawStreamSequence0 = new RawStreamSequence("Cannot find the 'token' Tokenization for RNA!?");
  2: assertEquals(0, rawStreamSequence0.getGCount());
  3: assertEquals(4, rawStreamSequence0.getTCount());
  4: assertEquals(3, rawStreamSequence0.getFormatType());
  5: assertEquals(2, rawStreamSequence0.getACount());
  6: assertEquals(0, rawStreamSequence0.getCCount());
  7: assertEquals(46, rawStreamSequence0.length());
  8: assertEquals(40, rawStreamSequence0.getOtherCount());
  9: assertNotNull(rawStreamSequence0);
 10: 
 11: Bases bases0 = new Bases(rawStreamSequence0);
 12: assertEquals(0, rawStreamSequence0.getGCount());
 13: assertEquals(4, rawStreamSequence0.getTCount());
 14: assertEquals(3, rawStreamSequence0.getFormatType());
 15: assertEquals(2, rawStreamSequence0.getACount());
 16: assertEquals(0, rawStreamSequence0.getCCount());
 17: assertEquals(46, rawStreamSequence0.length());
 18: assertEquals(40, rawStreamSequence0.getOtherCount());
 19: assertNotNull(bases0);
 20: assertEquals((-5), Bases.MIN_PRIORITY);
 21: assertEquals(1, Bases.FORWARD);
 22: assertEquals(0, Bases.MEDIUM_PRIORITY);
 23: assertEquals(5, Bases.MAX_PRIORITY);
 24: assertEquals(2, Bases.REVERSE);
 25: 
 26: Strand strand0 = bases0.getReverseStrand();
 27: assertEquals(0, rawStreamSequence0.getGCount());
 28: assertEquals(4, rawStreamSequence0.getTCount());
 29: assertEquals(3, rawStreamSequence0.getFormatType());
 30: assertEquals(2, rawStreamSequence0.getACount());
 31: assertEquals(0, rawStreamSequence0.getCCount());
 32: assertEquals(46, rawStreamSequence0.length());
 33: assertEquals(40, rawStreamSequence0.getOtherCount());
 34: assertFalse(strand0.isForwardStrand());
 35: assertEquals(2, strand0.getDirection());
 36: assertNotNull(strand0);
 37: assertEquals((-5), Bases.MIN_PRIORITY);
 38: assertEquals(1, Bases.FORWARD);
 39: assertEquals(0, Bases.MEDIUM_PRIORITY);
 40: assertEquals(5, Bases.MAX_PRIORITY);
 41: assertEquals(2, Bases.REVERSE);
 42: assertEquals(1, Strand.FORWARD);
 43: assertEquals(2, Strand.REVERSE);
 44: 
 45: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
 46: assertEquals(0, rawStreamSequence0.getGCount());
 47: assertEquals(4, rawStreamSequence0.getTCount());
 48: assertEquals(3, rawStreamSequence0.getFormatType());
 49: assertEquals(2, rawStreamSequence0.getACount());
 50: assertEquals(0, rawStreamSequence0.getCCount());
 51: assertEquals(46, rawStreamSequence0.length());
 52: assertEquals(40, rawStreamSequence0.getOtherCount());
 53: assertFalse(strand0.isForwardStrand());
 54: assertEquals(2, strand0.getDirection());
 55: assertFalse(aGWindowAlgorithm0.isRevCompDisplay());
 56: assertEquals(1, aGWindowAlgorithm0.getValueCount());
 57: assertEquals("AG Content (%)", aGWindowAlgorithm0.getAlgorithmName());
 58: assertEquals(1.4E-45F, aGWindowAlgorithm0.getUserMin(), 0.01F);
 59: assertFalse(aGWindowAlgorithm0.isUserMaxMin());
 60: assertEquals("ag_content", aGWindowAlgorithm0.getAlgorithmShortName());
 61: assertTrue(aGWindowAlgorithm0.scalingFlag());
 62: assertEquals(3.4028235E38F, aGWindowAlgorithm0.getUserMax(), 0.01F);
 63: assertNotNull(aGWindowAlgorithm0);
 64: assertEquals((-5), Bases.MIN_PRIORITY);
 65: assertEquals(1, Bases.FORWARD);
 66: assertEquals(0, Bases.MEDIUM_PRIORITY);
 67: assertEquals(5, Bases.MAX_PRIORITY);
 68: assertEquals(2, Bases.REVERSE);
 69: assertEquals(1, Strand.FORWARD);
 70: assertEquals(2, Strand.REVERSE);
 71: 
 72: Float float0 = aGWindowAlgorithm0.getAverage();
 73: assertEquals(0, rawStreamSequence0.getGCount());
 74: assertEquals(4, rawStreamSequence0.getTCount());
 75: assertEquals(3, rawStreamSequence0.getFormatType());
 76: assertEquals(2, rawStreamSequence0.getACount());
 77: assertEquals(0, rawStreamSequence0.getCCount());
 78: assertEquals(46, rawStreamSequence0.length());
 79: assertEquals(40, rawStreamSequence0.getOtherCount());
 80: assertFalse(strand0.isForwardStrand());
 81: assertEquals(2, strand0.getDirection());
 82: assertFalse(aGWindowAlgorithm0.isRevCompDisplay());
 83: assertEquals(1, aGWindowAlgorithm0.getValueCount());
 84: assertEquals("AG Content (%)", aGWindowAlgorithm0.getAlgorithmName());
 85: assertEquals(1.4E-45F, aGWindowAlgorithm0.getUserMin(), 0.01F);
 86: assertFalse(aGWindowAlgorithm0.isUserMaxMin());
 87: assertEquals("ag_content", aGWindowAlgorithm0.getAlgorithmShortName());
 88: assertTrue(aGWindowAlgorithm0.scalingFlag());
 89: assertEquals(3.4028235E38F, aGWindowAlgorithm0.getUserMax(), 0.01F);
 90: assertNotNull(float0);
 91: assertEquals(4.347826F, (float)float0, 0.01F);
 92: assertEquals((-5), Bases.MIN_PRIORITY);
 93: assertEquals(1, Bases.FORWARD);
 94: assertEquals(0, Bases.MEDIUM_PRIORITY);
 95: assertEquals(5, Bases.MAX_PRIORITY);
 96: assertEquals(2, Bases.REVERSE);
 97: assertEquals(1, Strand.FORWARD);
 98: assertEquals(2, Strand.REVERSE);

Test case 16

  1: Short short0 = new Short((short)2953);
  2: assertNotNull(short0);
  3: assertEquals((short)2953, (short)short0);
  4: 
  5: Integer integer0 = new Integer(103);
  6: assertNotNull(integer0);
  7: assertEquals(103, (int)integer0);
  8: 
  9: PartialSequence partialSequence0 = new PartialSequence((char[]) null, 0, 0, short0, integer0);
 10: assertEquals(103, (int)partialSequence0.getPhase());
 11: assertEquals(0, partialSequence0.length());
 12: assertEquals(0, partialSequence0.getACount());
 13: assertFalse(partialSequence0.isComplement());
 14: assertEquals(0, partialSequence0.getGCount());
 15: assertEquals(0, partialSequence0.getCCount());
 16: assertEquals(0, partialSequence0.getTCount());
 17: assertEquals((short)2953, (short)partialSequence0.getStrand());
 18: assertNotNull(partialSequence0);
 19: 
 20: Bases bases0 = new Bases(partialSequence0);
 21: assertEquals(103, (int)partialSequence0.getPhase());
 22: assertEquals(0, partialSequence0.length());
 23: assertEquals(0, partialSequence0.getACount());
 24: assertFalse(partialSequence0.isComplement());
 25: assertEquals(0, partialSequence0.getGCount());
 26: assertEquals(0, partialSequence0.getCCount());
 27: assertEquals(0, partialSequence0.getTCount());
 28: assertEquals((short)2953, (short)partialSequence0.getStrand());
 29: assertNotNull(bases0);
 30: assertEquals(2, Bases.REVERSE);
 31: assertEquals(5, Bases.MAX_PRIORITY);
 32: assertEquals((-5), Bases.MIN_PRIORITY);
 33: assertEquals(0, Bases.MEDIUM_PRIORITY);
 34: assertEquals(1, Bases.FORWARD);
 35: 
 36: Strand strand0 = bases0.getReverseStrand();
 37: assertEquals(103, (int)partialSequence0.getPhase());
 38: assertEquals(0, partialSequence0.length());
 39: assertEquals(0, partialSequence0.getACount());
 40: assertFalse(partialSequence0.isComplement());
 41: assertEquals(0, partialSequence0.getGCount());
 42: assertEquals(0, partialSequence0.getCCount());
 43: assertEquals(0, partialSequence0.getTCount());
 44: assertEquals((short)2953, (short)partialSequence0.getStrand());
 45: assertFalse(strand0.isForwardStrand());
 46: assertEquals(2, strand0.getDirection());
 47: assertNotNull(strand0);
 48: assertEquals(2, Bases.REVERSE);
 49: assertEquals(5, Bases.MAX_PRIORITY);
 50: assertEquals((-5), Bases.MIN_PRIORITY);
 51: assertEquals(0, Bases.MEDIUM_PRIORITY);
 52: assertEquals(1, Bases.FORWARD);
 53: assertEquals(2, Strand.REVERSE);
 54: assertEquals(1, Strand.FORWARD);
 55: 
 56: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
 57: assertEquals(103, (int)partialSequence0.getPhase());
 58: assertEquals(0, partialSequence0.length());
 59: assertEquals(0, partialSequence0.getACount());
 60: assertFalse(partialSequence0.isComplement());
 61: assertEquals(0, partialSequence0.getGCount());
 62: assertEquals(0, partialSequence0.getCCount());
 63: assertEquals(0, partialSequence0.getTCount());
 64: assertEquals((short)2953, (short)partialSequence0.getStrand());
 65: assertFalse(strand0.isForwardStrand());
 66: assertEquals(2, strand0.getDirection());
 67: assertEquals(3.4028235E38F, aGWindowAlgorithm0.getUserMax(), 0.01F);
 68: assertEquals("AG Content (%)", aGWindowAlgorithm0.getAlgorithmName());
 69: assertEquals(1, aGWindowAlgorithm0.getValueCount());
 70: assertFalse(aGWindowAlgorithm0.isRevCompDisplay());
 71: assertTrue(aGWindowAlgorithm0.scalingFlag());
 72: assertEquals(1.4E-45F, aGWindowAlgorithm0.getUserMin(), 0.01F);
 73: assertFalse(aGWindowAlgorithm0.isUserMaxMin());
 74: assertEquals("ag_content", aGWindowAlgorithm0.getAlgorithmShortName());
 75: assertNotNull(aGWindowAlgorithm0);
 76: assertEquals(2, Bases.REVERSE);
 77: assertEquals(5, Bases.MAX_PRIORITY);
 78: assertEquals((-5), Bases.MIN_PRIORITY);
 79: assertEquals(0, Bases.MEDIUM_PRIORITY);
 80: assertEquals(1, Bases.FORWARD);
 81: assertEquals(2, Strand.REVERSE);
 82: assertEquals(1, Strand.FORWARD);
 83: 
 84: Float float0 = aGWindowAlgorithm0.getAverage();
 85: assertEquals(103, (int)partialSequence0.getPhase());
 86: assertEquals(0, partialSequence0.length());
 87: assertEquals(0, partialSequence0.getACount());
 88: assertFalse(partialSequence0.isComplement());
 89: assertEquals(0, partialSequence0.getGCount());
 90: assertEquals(0, partialSequence0.getCCount());
 91: assertEquals(0, partialSequence0.getTCount());
 92: assertEquals((short)2953, (short)partialSequence0.getStrand());
 93: assertFalse(strand0.isForwardStrand());
 94: assertEquals(2, strand0.getDirection());
 95: assertEquals(3.4028235E38F, aGWindowAlgorithm0.getUserMax(), 0.01F);
 96: assertEquals("AG Content (%)", aGWindowAlgorithm0.getAlgorithmName());
 97: assertEquals(1, aGWindowAlgorithm0.getValueCount());
 98: assertFalse(aGWindowAlgorithm0.isRevCompDisplay());
 99: assertTrue(aGWindowAlgorithm0.scalingFlag());
100: assertEquals(1.4E-45F, aGWindowAlgorithm0.getUserMin(), 0.01F);
101: assertFalse(aGWindowAlgorithm0.isUserMaxMin());
102: assertEquals("ag_content", aGWindowAlgorithm0.getAlgorithmShortName());
103: assertNotNull(float0);
104: assertEquals(Float.NaN, (float)float0, 0.01F);
105: assertEquals(2, Bases.REVERSE);
106: assertEquals(5, Bases.MAX_PRIORITY);
107: assertEquals((-5), Bases.MIN_PRIORITY);
108: assertEquals(0, Bases.MEDIUM_PRIORITY);
109: assertEquals(1, Bases.FORWARD);
110: assertEquals(2, Strand.REVERSE);
111: assertEquals(1, Strand.FORWARD);

Source Code

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

EvoSuite Parameters

  • TARGET_CLASS: uk.ac.sanger.artemis.plot.AGWindowAlgorithm
  • Size: 16
  • Length: 82
  • criterion: LINE;BRANCH;EXCEPTION;WEAKMUTATION;OUTPUT;METHOD;METHODNOEXCEPTION;CBRANCH
  • Coverage: 0.8560475030271681
  • BranchCoverage: 0.7894736842105263
  • MethodCoverage: 1.0
  • OutputCoverage: 0.38513513513513514


Back to Overview