Summary

Test suite

Test case 1

  1: char char0 = '8';
  2: AminoAcidSequence.isLegalCodon('8');
  3: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Not(", false);
  4: aminoAcidSequence0.getMolecularWeight();
  5: aminoAcidSequence0.toString();
  6: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
  7: AminoAcidSequence.getSpacedTranslation(aminoAcidSequence1.codon_translation_array, false);
  8: AminoAcidSequence.getOneLetterCode(".");
  9: AminoAcidSequence.getCodonTranslation("Not(");
 10: AminoAcidSequence.getTranslation("Not(", true);
 11: aminoAcidSequence0.toString();
 12: char char1 = aminoAcidSequence0.elementAt((-1692));
 13: AminoAcidSequence.isStopCodon(char0);
 14: AminoAcidSequence.getAminoAcidType(char1);
 15: aminoAcidSequence0.getMolecularWeight();

Test case 2

  1: AminoAcidSequence.getOneLetterCode("khhg? yk*(IS");
  2: AminoAcidSequence.getThreeLetterAbbreviation('H');
  3: AminoAcidSequence.getSymbolIndex('H');
  4: char[] charArray0 = new char[6];
  5: charArray0[0] = '\uFFFF';
  6: charArray0[1] = 'H';
  7: charArray0[2] = '\uFFFF';
  8: charArray0[3] = 'H';
  9: charArray0[4] = 'H';
 10: charArray0[5] = 'H';
 11: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
 12: FastaStreamSequence fastaStreamSequence0 = new FastaStreamSequence("khhg? yk*(IS");
 13: Bases bases0 = new Bases(fastaStreamSequence0);
 14: AminoAcidSequence.isStopCodon('H');
 15: Strand strand0 = new Strand(bases0, 1);
 16: AGWindowAlgorithm aGWindowAlgorithm0 = new AGWindowAlgorithm(strand0);
 17: Bases bases1 = aGWindowAlgorithm0.getBases();
 18: aminoAcidSequence0.findMatch(bases1, (Marker) null, true, false, true);
 19: aminoAcidSequence0.containsStopCodon();
 20: aminoAcidSequence0.elementAt(8);

Test case 3

  1: char char0 = 'K';
  2: AminoAcidSequence.getAminoAcidType('K');
  3: String string0 = AccessibleContext.ACCESSIBLE_TABLE_ROW_DESCRIPTION_CHANGED;
  4: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("accessibleTableRowDescriptionChanged");
  5: aminoAcidSequence0.getMolecularWeight();
  6: boolean boolean0 = true;
  7: AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, boolean0);
  8: boolean boolean1 = false;
  9: AminoAcidSequence.getTranslation(string0, boolean1);
 10: String string1 = "";
 11: char char1 = AminoAcidSequence.getOneLetterCode(string1);
 12: String string2 = AminoAcidSequence.getThreeLetterAbbreviation(char0);
 13: String string3 = "Couldn't grab region of file";
 14: boolean boolean2 = true;
 15: AminoAcidSequence.getSymbolIndex(char0);
 16: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(string3, boolean2);
 17: AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, boolean2);
 18: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, boolean2);
 19: boolean boolean3 = true;
 20: AminoAcidSequence.getSpacedTranslation(string1, boolean3);
 21: AminoAcidSequence.getSymbolIndex(char1);
 22: AminoAcidSequence.getOneLetterCode(string2);
 23: AminoAcidSequence.getTranslation(aminoAcidSequence2.codon_translation_array, boolean0);
 24: String string4 = "";
 25: AminoAcidSequence.getTranslation(aminoAcidSequence1.codon_translation_array, boolean3);
 26: AminoAcidSequence.getSpacedTranslation(string4, boolean0);
 27: aminoAcidSequence2.length();
 28: String string5 = "Thr";
 29: AminoAcidSequence.getCodonTranslation(string5);
 30: int int0 = (-1259);
 31: aminoAcidSequence0.elementAt(int0);
 32: String string6 = "euk";
 33: AminoAcidSequence.getOneLetterCode(string6);

Test case 4

  1: String string0 = "Can't set weight to negative score: ";
  2: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("Can't set weight to negative score: ");
  3: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("Can't set weight to negative score: ", true);
  4: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
  5: aminoAcidSequence2.getMolecularWeight();
  6: boolean boolean0 = aminoAcidSequence0.checkForMatch(aminoAcidSequence1);
  7: aminoAcidSequence0.getMolecularWeight();
  8: aminoAcidSequence0.containsStopCodon();
  9: boolean boolean1 = false;
 10: AminoAcidSequence.getSpacedTranslation(string0, boolean1);
 11: String string1 = "Phe";
 12: AminoAcidSequence.getOneLetterCode(string1);
 13: AminoAcidSequence.getCodonTranslation(string1);
 14: AminoAcidSequence.getSpacedTranslation(string1, boolean0);
 15: int int0 = (-1032);
 16: AminoAcidSequence.getSymbolFromIndex(int0);
 17: boolean boolean2 = false;
 18: AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, boolean2);

Test case 5

  1: PipedReader pipedReader0 = new PipedReader();
  2: LinePushBackReader linePushBackReader0 = new LinePushBackReader(pipedReader0);
  3: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence(linePushBackReader0);
  4: Bases bases0 = new Bases(emblStreamSequence0);
  5: Strand strand0 = new Strand(bases0, bases0.MIN_PRIORITY);
  6: int int0 = 1108;
  7: Range range0 = new Range(int0, int0);
  8: boolean boolean0 = true;
  9: AminoAcidSequence aminoAcidSequence0 = strand0.getTranslation(range0, boolean0);
 10: String string0 = "Arg";
 11: Clipboard clipboard0 = new Clipboard(string0);
 12: Selection selection0 = new Selection(clipboard0);
 13: Marker marker0 = selection0.getEndBaseOfSelection();
 14: boolean boolean1 = false;
 15: aminoAcidSequence0.findMatch(bases0, marker0, boolean1, boolean0, boolean1);

Test case 6

  1: AminoAcidSequence.getCodonTranslation("FpH55Y9k7-5\"Kg/");
  2: AminoAcidSequence.getCodonTranslation('X', 'Q', '|');
  3: char[] charArray0 = new char[8];
  4: charArray0[0] = '.';
  5: charArray0[1] = 'X';
  6: charArray0[2] = '|';
  7: charArray0[3] = 'X';
  8: charArray0[4] = '.';
  9: charArray0[5] = '.';
 10: charArray0[6] = 'Q';
 11: charArray0[7] = 'X';
 12: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals("x  x  ", aminoAcidSequence0.toString());
 15: 
 16: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('.');
 17: assertEquals("---", string0);
 18: 
 19: AminoAcidSequence.getCodonTranslation("FpH55Y9k7-5\"Kg/");
 20: boolean boolean0 = AminoAcidSequence.isStopCodon('X');
 21: assertFalse(boolean0);

Test case 7

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("D0_r>,?K", true);
  2: AminoAcidSequence.setGeneCode();
  3: AminoAcidSequence.isLegalCodon('b');
  4: AminoAcidSequence.getAminoAcidType('b');
  5: AminoAcidSequence.setGeneCode();
  6: AminoAcidSequence.getSymbolIndex('b');
  7: aminoAcidSequence0.getMolecularWeight();
  8: String string0 = "";
  9: AminoAcidSequence.getOneLetterCode(string0);

Test case 8

  1: String string0 = "S&Dipm<2K";
  2: boolean boolean0 = false;
  3: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("S&Dipm<2K", false);
  4: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
  5: AminoAcidSequence.getThreeLetterAbbreviation('?');
  6: AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, boolean0);
  7: char char0 = 'q';
  8: AminoAcidSequence.getSymbolIndex(char0);
  9: boolean boolean1 = true;
 10: AminoAcidSequence.getTranslation(string0, boolean1);
 11: String string1 = "6\"N_OP&i+";
 12: char char1 = 'r';
 13: AminoAcidSequence.getThreeLetterAbbreviation(char1);
 14: AminoAcidSequence.getOneLetterCode(string1);
 15: aminoAcidSequence1.getMolecularWeight();
 16: char char2 = 'm';
 17: AminoAcidSequence.isStopCodon(char2);

Test case 9

  1: AminoAcidSequence.getThreeLetterAbbreviation(164);

Test case 10

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("X4ue;7}1#=\"y l43v");
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  4: assertEquals(5, AminoAcidSequence.STOP_AA);
  5: assertEquals(25, AminoAcidSequence.symbol_count);
  6: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals("X4ue;7}1#=\"y l43v", aminoAcidSequence0.toString());
 13: assertEquals(17, aminoAcidSequence0.length());
 14: assertTrue(aminoAcidSequence0.containsStopCodon());
 15: 
 16: AminoAcidSequence.getSymbolIndex('7');

Test case 11

  1: AminoAcidSequence.getSymbolFromIndex(392);

Test case 12

  1: char char0 = AminoAcidSequence.getCodonTranslation("*CUpuo#");
  2: assertEquals('.', char0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("*CUpuo#");
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  7: assertEquals(25, AminoAcidSequence.symbol_count);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 12: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 13: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals(8, aminoAcidSequence0.length());
 16: assertEquals("*CUpuo#", aminoAcidSequence0.toString());
 17: assertTrue(aminoAcidSequence0.containsStopCodon());
 18: 
 19: char char1 = AminoAcidSequence.getOneLetterCode("*CUpuo#");
 20: assertFalse(char1 == char0);
 21: assertEquals('\uFFFF', char1);
 22: 
 23: int int0 = AminoAcidSequence.getSymbolIndex('.');
 24: assertEquals(23, int0);
 25: 
 26: int int1 = aminoAcidSequence0.length();
 27: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 28: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 29: assertEquals(25, AminoAcidSequence.symbol_count);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertEquals(5, AminoAcidSequence.STOP_AA);
 32: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 33: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 34: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 35: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 36: assertFalse(int1 == int0);
 37: assertEquals(8, int1);
 38: assertEquals(8, aminoAcidSequence0.length());
 39: assertEquals("*CUpuo#", aminoAcidSequence0.toString());
 40: assertTrue(aminoAcidSequence0.containsStopCodon());
 41: 
 42: AminoAcidSequence.getSymbolFromIndex(25);

Test case 13

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("org.gmod.schema.sequence.FeatureCvTermPub", true);
  2: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  3: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  4: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  5: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  9: assertEquals(25, AminoAcidSequence.symbol_count);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(39, aminoAcidSequence0.length());
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals("x  x  x  x  x  x  x  x  x  i  x  x  x  ", aminoAcidSequence0.toString());

Test case 14

  1: char[] charArray0 = new char[0];
  2: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  7: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 12: assertArrayEquals(new char[] {}, charArray0);
 13: assertNotNull(aminoAcidSequence0);
 14: assertEquals("", aminoAcidSequence0.toString());
 15: assertEquals(0, aminoAcidSequence0.length());
 16: assertFalse(aminoAcidSequence0.containsStopCodon());

Test case 15

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence((String) null);
  2: assertEquals(25, AminoAcidSequence.symbol_count);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(5, AminoAcidSequence.STOP_AA);
  8: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  9: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertNull(aminoAcidSequence0.toString());
 13: 
 14: aminoAcidSequence0.elementAt(94);

Test case 16

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(1);
  2: assertEquals("Arg", string0);
  3: assertNotNull(string0);
  4: 
  5: String string1 = KeyEvent.getKeyModifiersText(1);
  6: assertFalse(string1.equals((Object)string0));
  7: assertEquals("\u21E7", string1);
  8: assertNotNull(string1);

Test case 17

  1: char char0 = AminoAcidSequence.getCodonTranslation("");
  2: assertEquals('.', char0);
  3: 
  4: AminoAcidSequence.getTranslation((String) null, true);

Test case 18

  1: AminoAcidSequence.setGeneCode();
  2: char char0 = AminoAcidSequence.getCodonTranslation("");
  3: assertEquals('.', char0);
  4: 
  5: boolean boolean0 = AminoAcidSequence.isLegalCodon('.');
  6: assertFalse(boolean0);
  7: 
  8: int int0 = AminoAcidSequence.getAminoAcidType('.');
  9: assertEquals(7, int0);
 10: 
 11: char char1 = AminoAcidSequence.getCodonTranslation('.', '.', '.');
 12: assertTrue(char1 == char0);
 13: assertEquals('.', char1);
 14: 
 15: boolean boolean1 = AminoAcidSequence.isLegalCodon('.');
 16: assertTrue(boolean1 == boolean0);
 17: assertFalse(boolean1);
 18: 
 19: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
 20: assertNotNull(simpleEntryGroup0);
 21: assertEquals(0, simpleEntryGroup0.refCount());
 22: assertEquals(0, simpleEntryGroup0.size());
 23: 
 24: Clipboard clipboard0 = new Clipboard("");
 25: assertNotNull(clipboard0);
 26: assertEquals("", clipboard0.getName());
 27: 
 28: Selection selection0 = new Selection(clipboard0);
 29: assertNotNull(selection0);
 30: assertEquals("", clipboard0.getName());
 31: 
 32: SimpleGotoEventSource simpleGotoEventSource0 = new SimpleGotoEventSource(simpleEntryGroup0);
 33: assertNotNull(simpleGotoEventSource0);
 34: assertEquals(0, simpleEntryGroup0.refCount());
 35: assertEquals(0, simpleEntryGroup0.size());
 36: 
 37: JFrame jFrame0 = new JFrame("U^R!");

Test case 19

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("org.gmod.schema.sequence.FeatureCvTermPub", true);
  2: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  3: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  4: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  5: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 10: assertEquals(25, AminoAcidSequence.symbol_count);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals("x  x  x  x  x  x  x  x  x  i  x  x  x  ", aminoAcidSequence0.toString());
 13: assertEquals(39, aminoAcidSequence0.length());
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: 
 16: aminoAcidSequence0.getMolecularWeight();

Test case 20

  1: AminoAcidSequence.setGeneCode();
  2: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("APqV|pi'!=(");
  3: assertEquals(25, AminoAcidSequence.symbol_count);
  4: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  8: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 12: assertNotNull(aminoAcidSequence0);
 13: assertEquals(11, aminoAcidSequence0.length());
 14: assertEquals("APqV|pi'!=(", aminoAcidSequence0.toString());
 15: assertFalse(aminoAcidSequence0.containsStopCodon());
 16: 
 17: char char0 = AminoAcidSequence.getOneLetterCode("APqV|pi'!=(");
 18: assertEquals('\uFFFF', char0);
 19: 
 20: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, false);
 21: assertEquals(25, AminoAcidSequence.symbol_count);
 22: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 23: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 24: assertEquals(5, AminoAcidSequence.STOP_AA);
 25: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 26: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 27: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 28: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 29: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 30: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 31: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 32: assertEquals(5, AminoAcidSequence.STOP_AA);
 33: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 34: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 35: assertEquals(25, AminoAcidSequence.symbol_count);
 36: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 39: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 40: assertNotNull(aminoAcidSequence1);
 41: assertEquals(11, aminoAcidSequence0.length());
 42: assertEquals("APqV|pi'!=(", aminoAcidSequence0.toString());
 43: assertFalse(aminoAcidSequence0.containsStopCodon());
 44: assertEquals(63, aminoAcidSequence1.length());
 45: assertFalse(aminoAcidSequence1.containsStopCodon());
 46: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence1.toString());
 47: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 48: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 49: 
 50: AminoAcidSequence.getSymbolIndex('\uFFFF');

Test case 21

  1: boolean boolean0 = AminoAcidSequence.isStopCodon('@');
  2: assertFalse(boolean0);
  3: 
  4: char char0 = AminoAcidSequence.getCodonTranslation("PlSm*/p<MF/px$H");
  5: assertEquals('.', char0);
  6: 
  7: char char1 = AminoAcidSequence.getCodonTranslation("PlSm*/p<MF/px$H");
  8: assertTrue(char1 == char0);
  9: assertEquals('.', char1);
 10: 
 11: AminoAcidSequence.getSpacedTranslation((String) null, false);

Test case 22

  1: char[] charArray0 = new char[0];
  2: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 12: assertArrayEquals(new char[] {}, charArray0);
 13: assertNotNull(aminoAcidSequence0);
 14: assertEquals(0, aminoAcidSequence0.length());
 15: assertFalse(aminoAcidSequence0.containsStopCodon());
 16: assertEquals("", aminoAcidSequence0.toString());
 17: 
 18: AminoAcidSequence.getOneLetterCode("");

Test case 23

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('P');
  2: assertTrue(boolean0);
  3: 
  4: AminoAcidSequence.getSymbolIndex('j');

Test case 24

  1: char char0 = AminoAcidSequence.getCodonTranslation('i', '', 'i');
  2: assertEquals('.', char0);
  3: 
  4: AminoAcidSequence.getCodonTranslation((String) null);

Test case 25

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("", true);
  2: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  3: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  4: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  5: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  6: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  7: assertEquals(25, AminoAcidSequence.symbol_count);
  8: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(5, AminoAcidSequence.STOP_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(0, aminoAcidSequence0.length());
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals("", aminoAcidSequence0.toString());
 15: 
 16: float float0 = aminoAcidSequence0.getMolecularWeight();
 17: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 18: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 19: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 20: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 21: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 22: assertEquals(25, AminoAcidSequence.symbol_count);
 23: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 24: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 25: assertEquals(5, AminoAcidSequence.STOP_AA);
 26: assertEquals(0.0F, float0, 0.01F);
 27: assertEquals(0, aminoAcidSequence0.length());
 28: assertFalse(aminoAcidSequence0.containsStopCodon());
 29: assertEquals("", aminoAcidSequence0.toString());
 30: 
 31: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("", true);
 32: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 33: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 34: assertEquals(5, AminoAcidSequence.STOP_AA);
 35: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 36: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 37: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 38: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 39: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 40: assertEquals(25, AminoAcidSequence.symbol_count);
 41: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 42: assertNotNull(aminoAcidSequence1);
 43: assertFalse(aminoAcidSequence1.containsStopCodon());
 44: assertEquals("", aminoAcidSequence1.toString());
 45: assertEquals(0, aminoAcidSequence1.length());
 46: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 47: 
 48: AminoAcidSequence.setGeneCode();
 49: AminoAcidSequence.getSymbolIndex('=');

Test case 26

  1: int int0 = AminoAcidSequence.getAminoAcidType('M');
  2: assertEquals(3, int0);
  3: 
  4: AminoAcidSequence.getThreeLetterAbbreviation(1664);

Test case 27

  1: AminoAcidSequence.setGeneCode();
  2: AminoAcidSequence.setGeneCode();
  3: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('A');
  4: assertEquals("Ala", string0);
  5: assertNotNull(string0);
  6: 
  7: int int0 = AminoAcidSequence.getAminoAcidType('A');
  8: assertEquals(3, int0);
  9: 
 10: boolean boolean0 = AminoAcidSequence.isLegalCodon('A');
 11: assertTrue(boolean0);

Test case 28

  1: char[] charArray0 = new char[0];
  2: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, false);
  3: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  4: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  5: assertEquals(5, AminoAcidSequence.STOP_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  9: assertEquals(25, AminoAcidSequence.symbol_count);
 10: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 11: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 12: assertArrayEquals(new char[] {}, charArray0);
 13: assertNotNull(aminoAcidSequence0);
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: assertEquals(0, aminoAcidSequence0.length());
 16: assertEquals("", aminoAcidSequence0.toString());
 17: 
 18: int int0 = AminoAcidSequence.getSymbolIndex('U');
 19: assertEquals(24, int0);

Test case 29

  1: char char0 = AminoAcidSequence.getCodonTranslation('%', '.', '%');
  2: assertEquals('.', char0);
  3: 
  4: int int0 = AminoAcidSequence.getSymbolIndex('.');
  5: assertEquals(23, int0);
  6: 
  7: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("");
  8: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  9: assertEquals(25, AminoAcidSequence.symbol_count);
 10: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 11: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 12: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 13: assertEquals(5, AminoAcidSequence.STOP_AA);
 14: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 15: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 16: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 17: assertNotNull(aminoAcidSequence0);
 18: assertEquals("", aminoAcidSequence0.toString());
 19: assertFalse(aminoAcidSequence0.containsStopCodon());
 20: assertEquals(0, aminoAcidSequence0.length());
 21: 
 22: AminoAcidSequence.setGeneCode();
 23: boolean boolean0 = AminoAcidSequence.isLegalCodon('>');
 24: assertFalse(boolean0);
 25: 
 26: AminoAcidSequence.getThreeLetterAbbreviation(25);

Test case 30

  1: int int0 = AminoAcidSequence.getAminoAcidType('N');
  2: assertEquals(0, int0);
  3: 
  4: char[] charArray0 = new char[7];
  5: charArray0[0] = 'N';
  6: charArray0[1] = 'N';
  7: charArray0[2] = 'N';
  8: charArray0[3] = 'N';
  9: charArray0[4] = 'N';
 10: charArray0[5] = 'N';
 11: charArray0[6] = 'N';
 12: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, false);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 15: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 16: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 17: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 18: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 19: assertEquals(5, AminoAcidSequence.STOP_AA);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 22: assertArrayEquals(new char[] {'N', 'N', 'N', 'N', 'N', 'N', 'N'}, charArray0);
 23: assertNotNull(aminoAcidSequence0);
 24: assertFalse(aminoAcidSequence0.containsStopCodon());
 25: assertEquals(".  .  ", aminoAcidSequence0.toString());
 26: assertEquals(6, aminoAcidSequence0.length());
 27: 
 28: boolean boolean0 = aminoAcidSequence0.containsStopCodon();
 29: assertEquals(25, AminoAcidSequence.symbol_count);
 30: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 31: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 32: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 33: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 34: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 35: assertEquals(5, AminoAcidSequence.STOP_AA);
 36: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 37: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 38: assertFalse(boolean0);
 39: assertArrayEquals(new char[] {'N', 'N', 'N', 'N', 'N', 'N', 'N'}, charArray0);
 40: assertFalse(aminoAcidSequence0.containsStopCodon());
 41: assertEquals(".  .  ", aminoAcidSequence0.toString());
 42: assertEquals(6, aminoAcidSequence0.length());

Test case 31

  1: int int0 = AminoAcidSequence.getSymbolIndex('I');
  2: assertEquals(9, int0);
  3: 
  4: AminoAcidSequence.setGeneCode();
  5: AminoAcidSequence.setGeneCode();
  6: int int1 = AminoAcidSequence.getAminoAcidType('Z');
  7: assertFalse(int1 == int0);
  8: assertEquals(7, int1);
  9: 
 10: boolean boolean0 = AminoAcidSequence.isStopCodon('I');
 11: assertFalse(boolean0);
 12: 
 13: char char0 = AminoAcidSequence.getSymbolFromIndex(9);
 14: assertEquals('i', char0);
 15: 
 16: int int2 = AminoAcidSequence.getAminoAcidType('}');
 17: assertTrue(int2 == int1);
 18: assertFalse(int2 == int0);
 19: assertEquals(7, int2);
 20: 
 21: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Val", false);
 22: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 23: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 24: assertEquals(5, AminoAcidSequence.STOP_AA);
 25: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 26: assertEquals(25, AminoAcidSequence.symbol_count);
 27: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 28: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 29: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 30: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 31: assertNotNull(aminoAcidSequence0);
 32: assertEquals(".", aminoAcidSequence0.toString());
 33: assertEquals(1, aminoAcidSequence0.length());
 34: assertFalse(aminoAcidSequence0.containsStopCodon());
 35: 
 36: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup((Bases) null);

Test case 32

  1: char[] charArray0 = new char[5];
  2: charArray0[0] = 'O';
  3: charArray0[1] = 'U';
  4: charArray0[2] = 'h';
  5: charArray0[3] = 'w';
  6: charArray0[4] = 'm';
  7: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
  8: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 11: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 12: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 13: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 14: assertEquals(25, AminoAcidSequence.symbol_count);
 15: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 16: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 17: assertArrayEquals(new char[] {'O', 'U', 'h', 'w', 'm'}, charArray0);
 18: assertNotNull(aminoAcidSequence0);
 19: assertFalse(aminoAcidSequence0.containsStopCodon());
 20: assertEquals("x  ", aminoAcidSequence0.toString());
 21: assertEquals(3, aminoAcidSequence0.length());
 22: 
 23: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, true);
 24: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 25: assertEquals(5, AminoAcidSequence.STOP_AA);
 26: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 27: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 28: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 29: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 30: assertEquals(25, AminoAcidSequence.symbol_count);
 31: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 32: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 33: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 34: assertEquals(5, AminoAcidSequence.STOP_AA);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(25, AminoAcidSequence.symbol_count);
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 39: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 40: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 41: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 42: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 43: assertArrayEquals(new char[] {'O', 'U', 'h', 'w', 'm'}, charArray0);
 44: assertNotNull(aminoAcidSequence1);
 45: assertFalse(aminoAcidSequence0.containsStopCodon());
 46: assertEquals("x  ", aminoAcidSequence0.toString());
 47: assertEquals(3, aminoAcidSequence0.length());
 48: assertFalse(aminoAcidSequence1.containsStopCodon());
 49: assertEquals("x  x  x  x  x  x  x  x  x  x  x  x  f  x  x  x  x  x  x  x  g  ", aminoAcidSequence1.toString());
 50: assertEquals(63, aminoAcidSequence1.length());
 51: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 52: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 53: 
 54: boolean boolean0 = aminoAcidSequence0.checkForMatch(aminoAcidSequence1);
 55: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 56: assertEquals(5, AminoAcidSequence.STOP_AA);
 57: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 58: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 59: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 60: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 61: assertEquals(25, AminoAcidSequence.symbol_count);
 62: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 63: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 64: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 65: assertEquals(5, AminoAcidSequence.STOP_AA);
 66: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 67: assertEquals(25, AminoAcidSequence.symbol_count);
 68: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 69: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 70: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 71: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 72: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 73: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 74: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 75: assertTrue(boolean0);
 76: assertArrayEquals(new char[] {'O', 'U', 'h', 'w', 'm'}, charArray0);
 77: assertFalse(aminoAcidSequence0.containsStopCodon());
 78: assertEquals("x  ", aminoAcidSequence0.toString());
 79: assertEquals(3, aminoAcidSequence0.length());
 80: assertFalse(aminoAcidSequence1.containsStopCodon());
 81: assertEquals("x  x  x  x  x  x  x  x  x  x  x  x  f  x  x  x  x  x  x  x  g  ", aminoAcidSequence1.toString());
 82: assertEquals(63, aminoAcidSequence1.length());
 83: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 84: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);

Test case 33

  1: int int0 = AminoAcidSequence.getAminoAcidType('P');
  2: assertEquals(4, int0);
  3: 
  4: char[] charArray0 = new char[1];
  5: charArray0[0] = 'P';
  6: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
  7: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  8: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  9: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 12: assertEquals(25, AminoAcidSequence.symbol_count);
 13: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 14: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 15: assertEquals(5, AminoAcidSequence.STOP_AA);
 16: assertArrayEquals(new char[] {'P'}, charArray0);
 17: assertNotNull(aminoAcidSequence0);
 18: assertFalse(aminoAcidSequence0.containsStopCodon());
 19: assertEquals("", aminoAcidSequence0.toString());
 20: assertEquals(0, aminoAcidSequence0.length());
 21: 
 22: String string0 = aminoAcidSequence0.toString();
 23: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 24: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 25: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 26: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 27: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 28: assertEquals(25, AminoAcidSequence.symbol_count);
 29: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 30: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 31: assertEquals(5, AminoAcidSequence.STOP_AA);
 32: assertEquals("", string0);
 33: assertArrayEquals(new char[] {'P'}, charArray0);
 34: assertNotNull(string0);
 35: assertFalse(aminoAcidSequence0.containsStopCodon());
 36: assertEquals("", aminoAcidSequence0.toString());
 37: assertEquals(0, aminoAcidSequence0.length());
 38: 
 39: String string1 = AminoAcidSequence.getThreeLetterAbbreviation('P');
 40: assertFalse(string1.equals((Object)string0));
 41: assertEquals("Pro", string1);
 42: assertNotNull(string1);
 43: 
 44: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("Pro", false);
 45: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 46: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 47: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 48: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 49: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 50: assertEquals(25, AminoAcidSequence.symbol_count);
 51: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 52: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 53: assertEquals(5, AminoAcidSequence.STOP_AA);
 54: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 55: assertNotNull(aminoAcidSequence1);
 56: assertEquals(1, aminoAcidSequence1.length());
 57: assertFalse(aminoAcidSequence1.containsStopCodon());
 58: assertEquals(".", aminoAcidSequence1.toString());
 59: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 60: 
 61: boolean boolean0 = aminoAcidSequence0.checkForMatch(aminoAcidSequence1);
 62: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 63: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 64: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 65: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 66: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 67: assertEquals(25, AminoAcidSequence.symbol_count);
 68: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 69: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 70: assertEquals(5, AminoAcidSequence.STOP_AA);
 71: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 72: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 73: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 74: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 75: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 76: assertEquals(25, AminoAcidSequence.symbol_count);
 77: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 78: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 79: assertEquals(5, AminoAcidSequence.STOP_AA);
 80: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 81: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 82: assertTrue(boolean0);
 83: assertArrayEquals(new char[] {'P'}, charArray0);
 84: assertFalse(aminoAcidSequence0.containsStopCodon());
 85: assertEquals("", aminoAcidSequence0.toString());
 86: assertEquals(0, aminoAcidSequence0.length());
 87: assertEquals(1, aminoAcidSequence1.length());
 88: assertFalse(aminoAcidSequence1.containsStopCodon());
 89: assertEquals(".", aminoAcidSequence1.toString());
 90: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 91: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);

Test case 34

  1: int int0 = AminoAcidSequence.getSymbolIndex('M');
  2: assertEquals(12, int0);
  3: 
  4: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  5: assertNotNull(simpleEntryGroup0);
  6: assertEquals(0, simpleEntryGroup0.size());
  7: assertEquals(0, simpleEntryGroup0.refCount());
  8: 
  9: Range range0 = new Range((-324), (-324));
 10: assertNotNull(range0);
 11: assertEquals(1, range0.getCount());
 12: assertEquals((-324), range0.getEnd());
 13: assertEquals((-324), range0.getStart());
 14: 
 15: simpleEntryGroup0.truncate(range0);

Test case 35

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("internal error - illegal one letter amino acid code");
  2: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals("internal error - illegal one letter amino acid code", aminoAcidSequence0.toString());
 13: assertEquals(51, aminoAcidSequence0.length());
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: 
 16: AminoAcidSequence.getSymbolIndex('\'');

Test case 36

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("!BG)h9IU2FzMHPJl", true);
  2: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 10: assertEquals(25, AminoAcidSequence.symbol_count);
 11: assertNotNull(aminoAcidSequence0);
 12: assertFalse(aminoAcidSequence0.containsStopCodon());
 13: assertEquals("xxxxx", aminoAcidSequence0.toString());
 14: assertEquals(5, aminoAcidSequence0.length());
 15: 
 16: AminoAcidSequence.setGeneCode();
 17: float float0 = aminoAcidSequence0.getMolecularWeight();
 18: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 19: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 20: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 21: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 22: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 23: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 24: assertEquals(5, AminoAcidSequence.STOP_AA);
 25: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 26: assertEquals(25, AminoAcidSequence.symbol_count);
 27: assertEquals((-72.06F), float0, 0.01F);
 28: assertFalse(aminoAcidSequence0.containsStopCodon());
 29: assertEquals("xxxxx", aminoAcidSequence0.toString());
 30: assertEquals(5, aminoAcidSequence0.length());
 31: 
 32: AminoAcidSequence.getOneLetterCode((String) null);

Test case 37

  1: int int0 = AminoAcidSequence.getAminoAcidType('E');
  2: assertEquals(2, int0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("'GsMz8l", true);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(5, AminoAcidSequence.STOP_AA);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 12: assertEquals(25, AminoAcidSequence.symbol_count);
 13: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals(6, aminoAcidSequence0.length());
 16: assertFalse(aminoAcidSequence0.containsStopCodon());
 17: assertEquals("x  x  ", aminoAcidSequence0.toString());

Test case 38

  1: AminoAcidSequence.getSymbolIndex('/');

Test case 39

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence((String) null);
  2: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  3: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  4: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  5: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  8: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  9: assertEquals(25, AminoAcidSequence.symbol_count);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertNull(aminoAcidSequence0.toString());
 13: 
 14: aminoAcidSequence0.length();

Test case 40

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("Q>eD, SY&s%", true);
  2: assertEquals(25, AminoAcidSequence.symbol_count);
  3: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  4: assertEquals(5, AminoAcidSequence.STOP_AA);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  8: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  9: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(9, aminoAcidSequence0.length());
 13: assertEquals("x  x  x  ", aminoAcidSequence0.toString());
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: 
 16: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Q>eD, SY&s%", true);
 17: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 18: assertEquals(25, AminoAcidSequence.symbol_count);
 19: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 20: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 21: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 22: assertEquals(5, AminoAcidSequence.STOP_AA);
 23: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 24: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 27: assertNotNull(aminoAcidSequence1);
 28: assertEquals(9, aminoAcidSequence1.length());
 29: assertEquals("x  x  x  ", aminoAcidSequence1.toString());
 30: assertFalse(aminoAcidSequence1.containsStopCodon());
 31: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 32: 
 33: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence1.codon_translation_array, false);
 34: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 35: assertEquals(25, AminoAcidSequence.symbol_count);
 36: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 39: assertEquals(5, AminoAcidSequence.STOP_AA);
 40: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 41: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 42: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 43: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 44: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 45: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 46: assertEquals(25, AminoAcidSequence.symbol_count);
 47: assertEquals(5, AminoAcidSequence.STOP_AA);
 48: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 49: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 50: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 51: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 52: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 53: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 54: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 55: assertNotNull(aminoAcidSequence2);
 56: assertEquals(9, aminoAcidSequence1.length());
 57: assertEquals("x  x  x  ", aminoAcidSequence1.toString());
 58: assertFalse(aminoAcidSequence1.containsStopCodon());
 59: assertEquals(21, aminoAcidSequence2.length());
 60: assertFalse(aminoAcidSequence2.containsStopCodon());
 61: assertEquals("............f.......g", aminoAcidSequence2.toString());
 62: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 63: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
 64: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 66: 
 67: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("Q>eD, SY&s%", false);
 68: assertEquals(25, AminoAcidSequence.symbol_count);
 69: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 70: assertEquals(5, AminoAcidSequence.STOP_AA);
 71: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 72: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 73: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 74: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 75: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 76: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 77: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 78: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 79: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 80: assertNotNull(aminoAcidSequence3);
 81: assertEquals("...", aminoAcidSequence3.toString());
 82: assertEquals(3, aminoAcidSequence3.length());
 83: assertFalse(aminoAcidSequence3.containsStopCodon());
 84: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
 85: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
 86: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
 87: 
 88: AminoAcidSequence aminoAcidSequence4 = AminoAcidSequence.getTranslation("Q>eD, SY&s%", true);
 89: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 90: assertEquals(25, AminoAcidSequence.symbol_count);
 91: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 92: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 93: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 94: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 95: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 96: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 97: assertEquals(5, AminoAcidSequence.STOP_AA);
 98: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence1));
 99: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence2));
100: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence3));
101: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence0));
102: assertNotNull(aminoAcidSequence4);
103: assertEquals("xxx", aminoAcidSequence4.toString());
104: assertFalse(aminoAcidSequence4.containsStopCodon());
105: assertEquals(3, aminoAcidSequence4.length());
106: assertNotSame(aminoAcidSequence4, aminoAcidSequence1);
107: assertNotSame(aminoAcidSequence4, aminoAcidSequence2);
108: assertNotSame(aminoAcidSequence4, aminoAcidSequence3);
109: assertNotSame(aminoAcidSequence4, aminoAcidSequence0);
110: 
111: int int0 = AminoAcidSequence.getSymbolIndex('r');
112: assertEquals(1, int0);
113: 
114: int int1 = AminoAcidSequence.getSymbolIndex('D');
115: assertFalse(int1 == int0);
116: assertEquals(3, int1);
117: 
118: String string0 = aminoAcidSequence0.toString();
119: assertEquals(25, AminoAcidSequence.symbol_count);
120: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
121: assertEquals(5, AminoAcidSequence.STOP_AA);
122: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
123: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
124: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
125: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
126: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
127: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
128: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
129: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
130: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
131: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
132: assertEquals("x  x  x  ", string0);
133: assertNotNull(string0);
134: assertEquals(9, aminoAcidSequence0.length());
135: assertEquals("x  x  x  ", aminoAcidSequence0.toString());
136: assertFalse(aminoAcidSequence0.containsStopCodon());
137: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
138: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
139: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
140: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
141: 
142: AminoAcidSequence.getSymbolIndex('j');

Test case 41

  1: boolean boolean0 = AminoAcidSequence.isStopCodon('&');
  2: assertFalse(boolean0);
  3: 
  4: boolean boolean1 = AminoAcidSequence.isStopCodon('B');
  5: assertTrue(boolean1 == boolean0);
  6: assertFalse(boolean1);
  7: 
  8: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence((String) null);
  9: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 10: assertEquals(5, AminoAcidSequence.STOP_AA);
 11: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 12: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 13: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 14: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 15: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 16: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 17: assertEquals(25, AminoAcidSequence.symbol_count);
 18: assertNotNull(aminoAcidSequence0);
 19: assertNull(aminoAcidSequence0.toString());
 20: 
 21: aminoAcidSequence0.getMolecularWeight();

Test case 42

  1: char char0 = AminoAcidSequence.getOneLetterCode("Phe");
  2: assertEquals('f', char0);
  3: 
  4: char char1 = AminoAcidSequence.getCodonTranslation("Phe");
  5: assertFalse(char1 == char0);
  6: assertEquals('.', char1);
  7: 
  8: char char2 = CharacterIterator.DONE;
  9: assertFalse(char2 == char1);
 10: assertFalse(char2 == char0);
 11: assertEquals('\uFFFF', char2);

Test case 43

  1: int int0 = AminoAcidSequence.getAminoAcidType('8');
  2: assertEquals(7, int0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Ala", false);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  7: assertEquals(25, AminoAcidSequence.symbol_count);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 12: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 13: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals(".", aminoAcidSequence0.toString());
 16: assertEquals(1, aminoAcidSequence0.length());
 17: assertFalse(aminoAcidSequence0.containsStopCodon());
 18: 
 19: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Ala", true);
 20: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 21: assertEquals(25, AminoAcidSequence.symbol_count);
 22: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 23: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 24: assertEquals(5, AminoAcidSequence.STOP_AA);
 25: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 26: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 27: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 28: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 29: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 30: assertNotNull(aminoAcidSequence1);
 31: assertEquals("x  ", aminoAcidSequence1.toString());
 32: assertFalse(aminoAcidSequence1.containsStopCodon());
 33: assertEquals(3, aminoAcidSequence1.length());
 34: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 35: 
 36: String string0 = aminoAcidSequence0.toString();
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 39: assertEquals(25, AminoAcidSequence.symbol_count);
 40: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 41: assertEquals(5, AminoAcidSequence.STOP_AA);
 42: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 43: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 44: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 45: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 46: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 47: assertEquals(".", string0);
 48: assertNotNull(string0);
 49: assertEquals(".", aminoAcidSequence0.toString());
 50: assertEquals(1, aminoAcidSequence0.length());
 51: assertFalse(aminoAcidSequence0.containsStopCodon());
 52: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);

Test case 44

  1: int int0 = AminoAcidSequence.getAminoAcidType('g');
  2: assertEquals(7, int0);
  3: 
  4: char char0 = AminoAcidSequence.getCodonTranslation('g', 'Z', 'Z');
  5: assertEquals('.', char0);
  6: 
  7: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("", true);
  8: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(25, AminoAcidSequence.symbol_count);
 11: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 12: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 13: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 14: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 15: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 16: assertEquals(5, AminoAcidSequence.STOP_AA);
 17: assertNotNull(aminoAcidSequence0);
 18: assertFalse(aminoAcidSequence0.containsStopCodon());
 19: assertEquals(0, aminoAcidSequence0.length());
 20: assertEquals("", aminoAcidSequence0.toString());
 21: 
 22: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('.');
 23: assertEquals("---", string0);
 24: assertNotNull(string0);
 25: 
 26: String string1 = aminoAcidSequence0.toString();
 27: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 28: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 29: assertEquals(25, AminoAcidSequence.symbol_count);
 30: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 31: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 32: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 33: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 34: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 35: assertEquals(5, AminoAcidSequence.STOP_AA);
 36: assertFalse(string1.equals((Object)string0));
 37: assertEquals("", string1);
 38: assertNotNull(string1);
 39: assertFalse(aminoAcidSequence0.containsStopCodon());
 40: assertEquals(0, aminoAcidSequence0.length());
 41: assertEquals("", aminoAcidSequence0.toString());
 42: 
 43: String string2 = aminoAcidSequence0.toString();
 44: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 45: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 46: assertEquals(25, AminoAcidSequence.symbol_count);
 47: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 48: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 49: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 50: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 51: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 52: assertEquals(5, AminoAcidSequence.STOP_AA);
 53: assertFalse(string2.equals((Object)string0));
 54: assertEquals("", string2);
 55: assertNotNull(string2);
 56: assertFalse(aminoAcidSequence0.containsStopCodon());
 57: assertEquals(0, aminoAcidSequence0.length());
 58: assertEquals("", aminoAcidSequence0.toString());
 59: 
 60: AminoAcidSequence.getSpacedTranslation((String) null, true);

Test case 45

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('t');
  2: assertEquals("Thr", string0);
  3: assertNotNull(string0);
  4: 
  5: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("Thr", false);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  8: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  9: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 12: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 13: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 14: assertEquals(5, AminoAcidSequence.STOP_AA);
 15: assertNotNull(aminoAcidSequence0);
 16: assertEquals(".  ", aminoAcidSequence0.toString());
 17: assertFalse(aminoAcidSequence0.containsStopCodon());
 18: assertEquals(3, aminoAcidSequence0.length());
 19: 
 20: AminoAcidSequence.setGeneCode();
 21: int int0 = AminoAcidSequence.getSymbolIndex('C');
 22: assertEquals(4, int0);
 23: 
 24: AminoAcidSequence.setGeneCode();
 25: aminoAcidSequence0.elementAt(510);

Test case 46

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(0);
  2: assertEquals("Ala", string0);
  3: assertNotNull(string0);
  4: 
  5: String string1 = AminoAcidSequence.getThreeLetterAbbreviation('t');
  6: assertFalse(string1.equals((Object)string0));
  7: assertEquals("Thr", string1);
  8: assertNotNull(string1);
  9: 
 10: char char0 = AminoAcidSequence.getCodonTranslation('t', 't', 't');
 11: assertEquals('f', char0);
 12: 
 13: int int0 = AminoAcidSequence.getAminoAcidType('8');
 14: assertEquals(7, int0);
 15: 
 16: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("x)]ru^jkDJ*", false);
 17: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 18: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 19: assertEquals(5, AminoAcidSequence.STOP_AA);
 20: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 21: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 22: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 23: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 24: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 25: assertEquals(25, AminoAcidSequence.symbol_count);
 26: assertNotNull(aminoAcidSequence0);
 27: assertFalse(aminoAcidSequence0.containsStopCodon());
 28: assertEquals(".  .  .  .  ", aminoAcidSequence0.toString());
 29: assertEquals(12, aminoAcidSequence0.length());
 30: 
 31: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Thr", false);
 32: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 33: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 34: assertEquals(25, AminoAcidSequence.symbol_count);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(5, AminoAcidSequence.STOP_AA);
 37: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 38: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 39: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 40: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 41: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 42: assertNotNull(aminoAcidSequence1);
 43: assertEquals(".  ", aminoAcidSequence1.toString());
 44: assertEquals(3, aminoAcidSequence1.length());
 45: assertFalse(aminoAcidSequence1.containsStopCodon());
 46: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 47: 
 48: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation("Ala", true);
 49: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 50: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 51: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 52: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 53: assertEquals(5, AminoAcidSequence.STOP_AA);
 54: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 55: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 56: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 57: assertEquals(25, AminoAcidSequence.symbol_count);
 58: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 59: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 60: assertNotNull(aminoAcidSequence2);
 61: assertFalse(aminoAcidSequence2.containsStopCodon());
 62: assertEquals("x  ", aminoAcidSequence2.toString());
 63: assertEquals(3, aminoAcidSequence2.length());
 64: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 66: 
 67: AminoAcidSequence.setGeneCode();
 68: int int1 = AminoAcidSequence.getSymbolIndex('C');
 69: assertFalse(int1 == int0);
 70: assertEquals(4, int1);
 71: 
 72: AminoAcidSequence.setGeneCode();
 73: aminoAcidSequence1.elementAt(510);

Test case 47

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(0);
  2: assertEquals("Ala", string0);
  3: assertNotNull(string0);
  4: 
  5: String string1 = AminoAcidSequence.getThreeLetterAbbreviation('t');
  6: assertFalse(string1.equals((Object)string0));
  7: assertEquals("Thr", string1);
  8: assertNotNull(string1);
  9: 
 10: char char0 = AminoAcidSequence.getCodonTranslation('t', 't', ';');
 11: assertEquals('.', char0);
 12: 
 13: int int0 = AminoAcidSequence.getAminoAcidType('8');
 14: assertEquals(7, int0);
 15: 
 16: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("x)]ru^jkDJ*", false);
 17: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 18: assertEquals(5, AminoAcidSequence.STOP_AA);
 19: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 22: assertEquals(25, AminoAcidSequence.symbol_count);
 23: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 24: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertNotNull(aminoAcidSequence0);
 27: assertEquals(12, aminoAcidSequence0.length());
 28: assertEquals(".  .  .  .  ", aminoAcidSequence0.toString());
 29: assertFalse(aminoAcidSequence0.containsStopCodon());
 30: 
 31: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Thr", false);
 32: assertEquals(25, AminoAcidSequence.symbol_count);
 33: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 34: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(5, AminoAcidSequence.STOP_AA);
 37: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 38: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 39: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 40: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 41: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 42: assertNotNull(aminoAcidSequence1);
 43: assertEquals(".  ", aminoAcidSequence1.toString());
 44: assertEquals(3, aminoAcidSequence1.length());
 45: assertFalse(aminoAcidSequence1.containsStopCodon());
 46: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 47: 
 48: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation("Ala", true);
 49: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 50: assertEquals(25, AminoAcidSequence.symbol_count);
 51: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 52: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 53: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 54: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 55: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 56: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 57: assertEquals(5, AminoAcidSequence.STOP_AA);
 58: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 59: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 60: assertNotNull(aminoAcidSequence2);
 61: assertFalse(aminoAcidSequence2.containsStopCodon());
 62: assertEquals(3, aminoAcidSequence2.length());
 63: assertEquals("x  ", aminoAcidSequence2.toString());
 64: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 66: 
 67: AminoAcidSequence.setGeneCode();
 68: int int1 = AminoAcidSequence.getSymbolIndex('C');
 69: assertFalse(int1 == int0);
 70: assertEquals(4, int1);
 71: 
 72: AminoAcidSequence.setGeneCode();
 73: aminoAcidSequence1.elementAt(510);

Test case 48

  1: int int0 = AminoAcidSequence.getAminoAcidType('K');
  2: assertEquals(1, int0);
  3: 
  4: String string0 = HTMLLayout.LOCATION_INFO_OPTION;
  5: assertEquals("LocationInfo", string0);
  6: assertNotNull(string0);
  7: 
  8: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("LocationInfo");
  9: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 10: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 11: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 12: assertEquals(5, AminoAcidSequence.STOP_AA);
 13: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 14: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 15: assertEquals(25, AminoAcidSequence.symbol_count);
 16: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 17: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 18: assertNotNull(aminoAcidSequence0);
 19: assertEquals(12, aminoAcidSequence0.length());
 20: assertFalse(aminoAcidSequence0.containsStopCodon());
 21: assertEquals("LocationInfo", aminoAcidSequence0.toString());
 22: 
 23: aminoAcidSequence0.getMolecularWeight();

Test case 49

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("", true);
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertFalse(aminoAcidSequence0.containsStopCodon());
 13: assertEquals("", aminoAcidSequence0.toString());
 14: assertEquals(0, aminoAcidSequence0.length());
 15: 
 16: char char0 = AminoAcidSequence.getOneLetterCode("GhJi?mUq7]");
 17: assertEquals('\uFFFF', char0);
 18: 
 19: int int0 = AminoAcidSequence.getSymbolIndex('l');
 20: assertEquals(10, int0);
 21: 
 22: int int1 = AminoAcidSequence.getSymbolIndex('l');
 23: assertTrue(int1 == int0);
 24: assertEquals(10, int1);
 25: 
 26: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("", true);
 27: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 28: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 29: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 30: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 31: assertEquals(25, AminoAcidSequence.symbol_count);
 32: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 33: assertEquals(5, AminoAcidSequence.STOP_AA);
 34: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 37: assertNotNull(aminoAcidSequence1);
 38: assertFalse(aminoAcidSequence1.containsStopCodon());
 39: assertEquals(0, aminoAcidSequence1.length());
 40: assertEquals("", aminoAcidSequence1.toString());
 41: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 42: 
 43: float float0 = aminoAcidSequence0.getMolecularWeight();
 44: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 45: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 46: assertEquals(25, AminoAcidSequence.symbol_count);
 47: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 48: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 49: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 50: assertEquals(5, AminoAcidSequence.STOP_AA);
 51: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 52: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 53: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 54: assertEquals(0.0F, float0, 0.01F);
 55: assertFalse(aminoAcidSequence0.containsStopCodon());
 56: assertEquals("", aminoAcidSequence0.toString());
 57: assertEquals(0, aminoAcidSequence0.length());
 58: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 59: 
 60: AminoAcidSequence.getOneLetterCode("");

Test case 50

  1: AminoAcidSequence.setGeneCode();
  2: char char0 = AminoAcidSequence.getCodonTranslation("-jGGqdT:jq?NETW>W8Q");
  3: assertEquals('.', char0);
  4: 
  5: AminoAcidSequence.setGeneCode();
  6: int int0 = AminoAcidSequence.getAminoAcidType('J');
  7: assertEquals(7, int0);
  8: 
  9: char[] charArray0 = new char[0];
 10: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
 11: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 12: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 13: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 14: assertEquals(5, AminoAcidSequence.STOP_AA);
 15: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 16: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 17: assertEquals(25, AminoAcidSequence.symbol_count);
 18: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 19: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 20: assertArrayEquals(new char[] {}, charArray0);
 21: assertNotNull(aminoAcidSequence0);
 22: assertEquals("", aminoAcidSequence0.toString());
 23: assertFalse(aminoAcidSequence0.containsStopCodon());
 24: assertEquals(0, aminoAcidSequence0.length());
 25: 
 26: AminoAcidSequence aminoAcidSequence1 = new AminoAcidSequence("-jGGqdT:jq?NETW>W8Q");
 27: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 28: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 29: assertEquals(25, AminoAcidSequence.symbol_count);
 30: assertEquals(5, AminoAcidSequence.STOP_AA);
 31: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 32: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 33: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 34: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 35: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 36: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 37: assertNotNull(aminoAcidSequence1);
 38: assertFalse(aminoAcidSequence1.containsStopCodon());
 39: assertEquals("-jGGqdT:jq?NETW>W8Q", aminoAcidSequence1.toString());
 40: assertEquals(19, aminoAcidSequence1.length());
 41: 
 42: boolean boolean0 = aminoAcidSequence0.checkForMatch(aminoAcidSequence1);
 43: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 44: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 45: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 46: assertEquals(5, AminoAcidSequence.STOP_AA);
 47: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 48: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 49: assertEquals(25, AminoAcidSequence.symbol_count);
 50: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 51: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 52: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 53: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 54: assertEquals(25, AminoAcidSequence.symbol_count);
 55: assertEquals(5, AminoAcidSequence.STOP_AA);
 56: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 57: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 58: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 59: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 60: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 61: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 62: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 63: assertTrue(boolean0);
 64: assertArrayEquals(new char[] {}, charArray0);
 65: assertEquals("", aminoAcidSequence0.toString());
 66: assertFalse(aminoAcidSequence0.containsStopCodon());
 67: assertEquals(0, aminoAcidSequence0.length());
 68: assertFalse(aminoAcidSequence1.containsStopCodon());
 69: assertEquals("-jGGqdT:jq?NETW>W8Q", aminoAcidSequence1.toString());
 70: assertEquals(19, aminoAcidSequence1.length());
 71: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 72: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 73: 
 74: char char1 = AminoAcidSequence.getCodonTranslation("Iau=0E?+p^wU");
 75: assertTrue(char1 == char0);
 76: assertEquals('.', char1);

Test case 51

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("feature_labels");
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  4: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertFalse(aminoAcidSequence0.containsStopCodon());
 13: assertEquals("feature_labels", aminoAcidSequence0.toString());
 14: assertEquals(14, aminoAcidSequence0.length());
 15: 
 16: Short short0 = new Short((short) (-27008));
 17: assertEquals((short) (-27008), (short)short0);
 18: assertNotNull(short0);
 19: 
 20: PartialSequence partialSequence0 = new PartialSequence(aminoAcidSequence0.codon_translation_array, 0, 7, short0, (Integer) 2);
 21: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 22: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 23: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 24: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 25: assertEquals(25, AminoAcidSequence.symbol_count);
 26: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 27: assertEquals(5, AminoAcidSequence.STOP_AA);
 28: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 29: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 30: assertNotNull(partialSequence0);
 31: assertFalse(aminoAcidSequence0.containsStopCodon());
 32: assertEquals("feature_labels", aminoAcidSequence0.toString());
 33: assertEquals(14, aminoAcidSequence0.length());
 34: assertEquals(0, partialSequence0.length());
 35: assertEquals(0, partialSequence0.getGCount());
 36: assertEquals(2, (int)partialSequence0.getPhase());
 37: assertEquals(64, partialSequence0.getOtherCount());
 38: assertEquals(0, partialSequence0.getTCount());
 39: assertEquals(0, partialSequence0.getACount());
 40: assertEquals(0, partialSequence0.getCCount());
 41: assertEquals((short) (-27008), (short)partialSequence0.getStrand());
 42: assertFalse(partialSequence0.isComplement());
 43: 
 44: Bases bases0 = new Bases(partialSequence0);
 45: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 46: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 47: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 48: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 49: assertEquals(25, AminoAcidSequence.symbol_count);
 50: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 51: assertEquals(5, AminoAcidSequence.STOP_AA);
 52: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 53: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 54: assertEquals(5, Bases.MAX_PRIORITY);
 55: assertEquals(2, Bases.REVERSE);
 56: assertEquals((-5), Bases.MIN_PRIORITY);
 57: assertEquals(0, Bases.MEDIUM_PRIORITY);
 58: assertEquals(1, Bases.FORWARD);
 59: assertNotNull(bases0);
 60: assertFalse(aminoAcidSequence0.containsStopCodon());
 61: assertEquals("feature_labels", aminoAcidSequence0.toString());
 62: assertEquals(14, aminoAcidSequence0.length());
 63: assertEquals(0, partialSequence0.length());
 64: assertEquals(0, partialSequence0.getGCount());
 65: assertEquals(2, (int)partialSequence0.getPhase());
 66: assertEquals(64, partialSequence0.getOtherCount());
 67: assertEquals(0, partialSequence0.getTCount());
 68: assertEquals(0, partialSequence0.getACount());
 69: assertEquals(0, partialSequence0.getCCount());
 70: assertEquals((short) (-27008), (short)partialSequence0.getStrand());
 71: assertFalse(partialSequence0.isComplement());
 72: 
 73: Clipboard clipboard0 = new Clipboard("feature_labels");
 74: assertNotNull(clipboard0);
 75: assertEquals("feature_labels", clipboard0.getName());
 76: 
 77: Selection selection0 = new Selection(clipboard0);
 78: assertNotNull(selection0);
 79: assertEquals("feature_labels", clipboard0.getName());
 80: 
 81: Marker marker0 = selection0.getHighestBaseOfSelection();
 82: assertNull(marker0);
 83: assertEquals("feature_labels", clipboard0.getName());
 84: 
 85: MarkerRange markerRange0 = aminoAcidSequence0.findMatch(bases0, (Marker) null, true, true, false);
 86: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 87: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 88: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 89: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 90: assertEquals(25, AminoAcidSequence.symbol_count);
 91: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 92: assertEquals(5, AminoAcidSequence.STOP_AA);
 93: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 94: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 95: assertEquals(5, Bases.MAX_PRIORITY);
 96: assertEquals(2, Bases.REVERSE);
 97: assertEquals((-5), Bases.MIN_PRIORITY);
 98: assertEquals(0, Bases.MEDIUM_PRIORITY);
 99: assertEquals(1, Bases.FORWARD);
100: assertNull(markerRange0);
101: assertFalse(aminoAcidSequence0.containsStopCodon());
102: assertEquals("feature_labels", aminoAcidSequence0.toString());
103: assertEquals(14, aminoAcidSequence0.length());
104: assertEquals(0, partialSequence0.length());
105: assertEquals(0, partialSequence0.getGCount());
106: assertEquals(2, (int)partialSequence0.getPhase());
107: assertEquals(64, partialSequence0.getOtherCount());
108: assertEquals(0, partialSequence0.getTCount());
109: assertEquals(0, partialSequence0.getACount());
110: assertEquals(0, partialSequence0.getCCount());
111: assertEquals((short) (-27008), (short)partialSequence0.getStrand());
112: assertFalse(partialSequence0.isComplement());
113: 
114: int int0 = AminoAcidSequence.getSymbolIndex('S');
115: assertEquals(15, int0);
116: 
117: int int1 = AminoAcidSequence.getAminoAcidType(' ');
118: assertFalse(int1 == int0);
119: assertEquals(7, int1);

Test case 52

  1: AminoAcidSequence.getSpacedTranslation((char[]) null, false);

Test case 53

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Gln", true);
  2: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  3: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  4: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  5: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(5, AminoAcidSequence.STOP_AA);
  8: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  9: assertEquals(25, AminoAcidSequence.symbol_count);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals("x", aminoAcidSequence0.toString());
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals(1, aminoAcidSequence0.length());
 15: 
 16: int int0 = aminoAcidSequence0.length();
 17: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 18: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 19: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 20: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 21: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 22: assertEquals(5, AminoAcidSequence.STOP_AA);
 23: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 24: assertEquals(25, AminoAcidSequence.symbol_count);
 25: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 26: assertEquals(1, int0);
 27: assertEquals("x", aminoAcidSequence0.toString());
 28: assertFalse(aminoAcidSequence0.containsStopCodon());
 29: assertEquals(1, aminoAcidSequence0.length());
 30: 
 31: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Q-~Tj", true);
 32: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 33: assertEquals(5, AminoAcidSequence.STOP_AA);
 34: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 35: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 36: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 37: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 38: assertEquals(25, AminoAcidSequence.symbol_count);
 39: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 40: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 41: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 42: assertNotNull(aminoAcidSequence1);
 43: assertEquals(3, aminoAcidSequence1.length());
 44: assertFalse(aminoAcidSequence1.containsStopCodon());
 45: assertEquals("x  ", aminoAcidSequence1.toString());
 46: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 47: 
 48: char char0 = AminoAcidSequence.getOneLetterCode("Gln");
 49: assertEquals('q', char0);
 50: 
 51: Clipboard clipboard0 = new Clipboard("Gln");
 52: assertNotNull(clipboard0);
 53: assertEquals("Gln", clipboard0.getName());
 54: 
 55: Selection selection0 = new Selection(clipboard0);
 56: assertNotNull(selection0);
 57: assertEquals("Gln", clipboard0.getName());
 58: 
 59: Marker marker0 = selection0.getStartBaseOfSelection();
 60: assertNull(marker0);
 61: assertEquals("Gln", clipboard0.getName());
 62: 
 63: aminoAcidSequence1.findMatch((Bases) null, (Marker) null, false, true, true);

Test case 54

  1: int int0 = AminoAcidSequence.getSymbolIndex('G');
  2: assertEquals(7, int0);
  3: 
  4: AminoAcidSequence.getOneLetterCode("");

Test case 55

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon(',');
  2: assertFalse(boolean0);
  3: 
  4: AminoAcidSequence.getSpacedTranslation((char[]) null, true);

Test case 56

  1: AminoAcidSequence.getTranslation((char[]) null, true);

Test case 57

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('v');
  2: assertTrue(boolean0);
  3: 
  4: int int0 = AminoAcidSequence.getAminoAcidType('v');
  5: assertEquals(7, int0);
  6: 
  7: int int1 = AminoAcidSequence.getAminoAcidType('\"');
  8: assertTrue(int1 == int0);
  9: assertEquals(7, int1);
 10: 
 11: int int2 = AminoAcidSequence.getAminoAcidType('c');
 12: assertTrue(int2 == int1);
 13: assertTrue(int2 == int0);
 14: assertEquals(7, int2);
 15: 
 16: int int3 = AminoAcidSequence.getSymbolIndex('c');
 17: assertFalse(int3 == int2);
 18: assertFalse(int3 == int0);
 19: assertFalse(int3 == int1);
 20: assertEquals(4, int3);
 21: 
 22: char[] charArray0 = new char[9];
 23: charArray0[0] = '\"';
 24: charArray0[1] = '\"';
 25: charArray0[2] = 'c';
 26: charArray0[3] = '\"';
 27: charArray0[4] = '\"';
 28: charArray0[5] = '\"';
 29: charArray0[6] = 'c';
 30: charArray0[7] = 'v';
 31: charArray0[8] = 'c';
 32: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
 33: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 34: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 35: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 36: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 37: assertEquals(5, AminoAcidSequence.STOP_AA);
 38: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 39: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 40: assertEquals(25, AminoAcidSequence.symbol_count);
 41: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 42: assertArrayEquals(new char[] {'\"', '\"', 'c', '\"', '\"', '\"', 'c', 'v', 'c'}, charArray0);
 43: assertNotNull(aminoAcidSequence0);
 44: assertEquals(9, aminoAcidSequence0.length());
 45: assertFalse(aminoAcidSequence0.containsStopCodon());
 46: assertEquals("x  x  x  ", aminoAcidSequence0.toString());

Test case 58

  1: int int0 = AminoAcidSequence.getSymbolIndex('t');
  2: assertEquals(16, int0);
  3: 
  4: boolean boolean0 = AminoAcidSequence.isLegalCodon('{');
  5: assertFalse(boolean0);
  6: 
  7: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("Trp");
  8: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  9: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 10: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 11: assertEquals(5, AminoAcidSequence.STOP_AA);
 12: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 13: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 14: assertEquals(25, AminoAcidSequence.symbol_count);
 15: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 16: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 17: assertNotNull(aminoAcidSequence0);
 18: assertEquals(3, aminoAcidSequence0.length());
 19: assertEquals("Trp", aminoAcidSequence0.toString());
 20: assertFalse(aminoAcidSequence0.containsStopCodon());
 21: 
 22: AminoAcidSequence.setGeneCode();
 23: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Trp", false);
 24: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 25: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 26: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 27: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 28: assertEquals(5, AminoAcidSequence.STOP_AA);
 29: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 30: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 31: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 32: assertEquals(25, AminoAcidSequence.symbol_count);
 33: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 34: assertNotNull(aminoAcidSequence1);
 35: assertEquals(".  ", aminoAcidSequence1.toString());
 36: assertFalse(aminoAcidSequence1.containsStopCodon());
 37: assertEquals(3, aminoAcidSequence1.length());
 38: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 39: 
 40: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence1.codon_translation_array, false);
 41: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 42: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 43: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 44: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 45: assertEquals(5, AminoAcidSequence.STOP_AA);
 46: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 47: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 48: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 49: assertEquals(25, AminoAcidSequence.symbol_count);
 50: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 51: assertEquals(25, AminoAcidSequence.symbol_count);
 52: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 53: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 54: assertEquals(5, AminoAcidSequence.STOP_AA);
 55: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 56: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 57: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 58: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 59: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 60: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 61: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 62: assertNotNull(aminoAcidSequence2);
 63: assertEquals(".  ", aminoAcidSequence1.toString());
 64: assertFalse(aminoAcidSequence1.containsStopCodon());
 65: assertEquals(3, aminoAcidSequence1.length());
 66: assertEquals(63, aminoAcidSequence2.length());
 67: assertFalse(aminoAcidSequence2.containsStopCodon());
 68: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence2.toString());
 69: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
 70: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 71: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 72: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 73: 
 74: AminoAcidSequence.getThreeLetterAbbreviation('}');

Test case 59

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("");
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 10: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertFalse(aminoAcidSequence0.containsStopCodon());
 13: assertEquals(0, aminoAcidSequence0.length());
 14: assertEquals("", aminoAcidSequence0.toString());
 15: 
 16: AminoAcidSequence.setGeneCode();
 17: char char0 = AminoAcidSequence.getOneLetterCode("d7Fg1y_a*Phbinw ");
 18: assertEquals('\uFFFF', char0);
 19: 
 20: AminoAcidSequence.getSymbolIndex('`');

Test case 60

  1: char char0 = AminoAcidSequence.getCodonTranslation('k', 'k', 'S');
  2: assertEquals('.', char0);
  3: 
  4: char char1 = AminoAcidSequence.getCodonTranslation('.', '.', 'k');
  5: assertTrue(char1 == char0);
  6: assertEquals('.', char1);
  7: 
  8: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("~");
  9: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 10: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 11: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 12: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 13: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 14: assertEquals(5, AminoAcidSequence.STOP_AA);
 15: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 16: assertEquals(25, AminoAcidSequence.symbol_count);
 17: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 18: assertNotNull(aminoAcidSequence0);
 19: assertFalse(aminoAcidSequence0.containsStopCodon());
 20: assertEquals("~", aminoAcidSequence0.toString());
 21: assertEquals(1, aminoAcidSequence0.length());
 22: 
 23: RawStreamSequence rawStreamSequence0 = new RawStreamSequence("KX`_!gxk3K(*9G\"6vsK");
 24: assertNotNull(rawStreamSequence0);
 25: assertEquals(18, rawStreamSequence0.getOtherCount());
 26: assertEquals(3, rawStreamSequence0.getFormatType());
 27: assertEquals(0, rawStreamSequence0.getACount());
 28: assertEquals(1, rawStreamSequence0.getGCount());
 29: assertEquals(0, rawStreamSequence0.getCCount());
 30: assertEquals(0, rawStreamSequence0.getTCount());
 31: assertEquals(19, rawStreamSequence0.length());
 32: 
 33: Bases bases0 = new Bases(rawStreamSequence0);
 34: assertEquals(2, Bases.REVERSE);
 35: assertEquals(1, Bases.FORWARD);
 36: assertEquals((-5), Bases.MIN_PRIORITY);
 37: assertEquals(0, Bases.MEDIUM_PRIORITY);
 38: assertEquals(5, Bases.MAX_PRIORITY);
 39: assertNotNull(bases0);
 40: assertEquals(18, rawStreamSequence0.getOtherCount());
 41: assertEquals(3, rawStreamSequence0.getFormatType());
 42: assertEquals(0, rawStreamSequence0.getACount());
 43: assertEquals(1, rawStreamSequence0.getGCount());
 44: assertEquals(0, rawStreamSequence0.getCCount());
 45: assertEquals(0, rawStreamSequence0.getTCount());
 46: assertEquals(19, rawStreamSequence0.length());
 47: 
 48: Clipboard clipboard0 = new Clipboard("KX`_!gxk3K(*9G\"6vsK");
 49: assertNotNull(clipboard0);
 50: assertEquals("KX`_!gxk3K(*9G\"6vsK", clipboard0.getName());
 51: 
 52: Selection selection0 = new Selection(clipboard0);
 53: assertNotNull(selection0);
 54: assertEquals("KX`_!gxk3K(*9G\"6vsK", clipboard0.getName());
 55: 
 56: Marker marker0 = selection0.getEndBaseOfSelection();
 57: assertNull(marker0);
 58: assertEquals("KX`_!gxk3K(*9G\"6vsK", clipboard0.getName());
 59: 
 60: MarkerRange markerRange0 = aminoAcidSequence0.findMatch(bases0, (Marker) null, false, false, false);
 61: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 62: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 63: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 64: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 65: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 66: assertEquals(5, AminoAcidSequence.STOP_AA);
 67: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 68: assertEquals(25, AminoAcidSequence.symbol_count);
 69: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 70: assertEquals(2, Bases.REVERSE);
 71: assertEquals(1, Bases.FORWARD);
 72: assertEquals((-5), Bases.MIN_PRIORITY);
 73: assertEquals(0, Bases.MEDIUM_PRIORITY);
 74: assertEquals(5, Bases.MAX_PRIORITY);
 75: assertNull(markerRange0);
 76: assertFalse(aminoAcidSequence0.containsStopCodon());
 77: assertEquals("~", aminoAcidSequence0.toString());
 78: assertEquals(1, aminoAcidSequence0.length());
 79: assertEquals(18, rawStreamSequence0.getOtherCount());
 80: assertEquals(3, rawStreamSequence0.getFormatType());
 81: assertEquals(0, rawStreamSequence0.getACount());
 82: assertEquals(1, rawStreamSequence0.getGCount());
 83: assertEquals(0, rawStreamSequence0.getCCount());
 84: assertEquals(0, rawStreamSequence0.getTCount());
 85: assertEquals(19, rawStreamSequence0.length());
 86: 
 87: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
 88: assertEquals(2, Bases.REVERSE);
 89: assertEquals(1, Bases.FORWARD);
 90: assertEquals((-5), Bases.MIN_PRIORITY);
 91: assertEquals(0, Bases.MEDIUM_PRIORITY);
 92: assertEquals(5, Bases.MAX_PRIORITY);
 93: assertNotNull(simpleEntryGroup0);
 94: assertEquals(18, rawStreamSequence0.getOtherCount());
 95: assertEquals(3, rawStreamSequence0.getFormatType());
 96: assertEquals(0, rawStreamSequence0.getACount());
 97: assertEquals(1, rawStreamSequence0.getGCount());
 98: assertEquals(0, rawStreamSequence0.getCCount());
 99: assertEquals(0, rawStreamSequence0.getTCount());
100: assertEquals(19, rawStreamSequence0.length());
101: assertEquals(0, simpleEntryGroup0.refCount());
102: assertEquals(0, simpleEntryGroup0.size());
103: 
104: simpleEntryGroup0.featureAt(0);

Test case 61

  1: AminoAcidSequence.getSymbolIndex('$');

Test case 62

  1: int int0 = AminoAcidSequence.getAminoAcidType('[');
  2: assertEquals(7, int0);
  3: 
  4: char[] charArray0 = new char[8];
  5: charArray0[0] = '[';
  6: charArray0[1] = '[';
  7: charArray0[2] = '[';
  8: charArray0[3] = '[';
  9: charArray0[4] = '[';
 10: charArray0[5] = '[';
 11: charArray0[6] = '[';
 12: charArray0[7] = '[';
 13: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
 14: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 15: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 16: assertEquals(5, AminoAcidSequence.STOP_AA);
 17: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 18: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 19: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 20: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 21: assertEquals(25, AminoAcidSequence.symbol_count);
 22: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 23: assertArrayEquals(new char[] {'[', '[', '[', '[', '[', '[', '[', '['}, charArray0);
 24: assertNotNull(aminoAcidSequence0);
 25: assertEquals(2, aminoAcidSequence0.length());
 26: assertFalse(aminoAcidSequence0.containsStopCodon());
 27: assertEquals("xx", aminoAcidSequence0.toString());
 28: 
 29: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation(charArray0, false);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertEquals(5, AminoAcidSequence.STOP_AA);
 32: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 33: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 34: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 35: assertEquals(25, AminoAcidSequence.symbol_count);
 36: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 37: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 38: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 39: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 40: assertArrayEquals(new char[] {'[', '[', '[', '[', '[', '[', '[', '['}, charArray0);
 41: assertNotNull(aminoAcidSequence1);
 42: assertEquals(6, aminoAcidSequence1.length());
 43: assertEquals(".  .  ", aminoAcidSequence1.toString());
 44: assertFalse(aminoAcidSequence1.containsStopCodon());
 45: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 46: 
 47: AminoAcidSequence.setGeneCode();
 48: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(charArray0, true);
 49: assertEquals(25, AminoAcidSequence.symbol_count);
 50: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 51: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 52: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 53: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 54: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 55: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 56: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 57: assertEquals(5, AminoAcidSequence.STOP_AA);
 58: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 59: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 60: assertArrayEquals(new char[] {'[', '[', '[', '[', '[', '[', '[', '['}, charArray0);
 61: assertNotNull(aminoAcidSequence2);
 62: assertFalse(aminoAcidSequence2.containsStopCodon());
 63: assertEquals(2, aminoAcidSequence2.length());
 64: assertEquals("xx", aminoAcidSequence2.toString());
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 66: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 67: 
 68: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getSpacedTranslation("\" was loaded by ", true);
 69: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 70: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 71: assertEquals(25, AminoAcidSequence.symbol_count);
 72: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 73: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 74: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 75: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 76: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 77: assertEquals(5, AminoAcidSequence.STOP_AA);
 78: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 79: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 80: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 81: assertNotNull(aminoAcidSequence3);
 82: assertEquals(15, aminoAcidSequence3.length());
 83: assertFalse(aminoAcidSequence3.containsStopCodon());
 84: assertEquals("x  x  x  x  x  ", aminoAcidSequence3.toString());
 85: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
 86: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
 87: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
 88: 
 89: AminoAcidSequence.getSymbolIndex('[');

Test case 63

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("X4ue;7}1#=\"y l43v");
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  9: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 10: assertEquals(5, AminoAcidSequence.STOP_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(17, aminoAcidSequence0.length());
 13: assertEquals("X4ue;7}1#=\"y l43v", aminoAcidSequence0.toString());
 14: assertTrue(aminoAcidSequence0.containsStopCodon());
 15: 
 16: int int0 = AminoAcidSequence.getSymbolIndex('+');
 17: assertEquals(22, int0);
 18: 
 19: int int1 = Level.TRACE_INT;
 20: assertFalse(int1 == int0);
 21: assertEquals(5000, int1);

Test case 64

  1: char char0 = AminoAcidSequence.getCodonTranslation('\\', '\\', '\\');
  2: assertEquals('.', char0);
  3: 
  4: int int0 = AminoAcidSequence.getAminoAcidType('-');
  5: assertEquals(7, int0);
  6: 
  7: Bases bases0 = new Bases((Sequence) null);
  8: assertEquals(5, Bases.MAX_PRIORITY);
  9: assertEquals(2, Bases.REVERSE);
 10: assertEquals(0, Bases.MEDIUM_PRIORITY);
 11: assertEquals(1, Bases.FORWARD);
 12: assertEquals((-5), Bases.MIN_PRIORITY);
 13: assertNotNull(bases0);
 14: 
 15: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
 16: assertEquals(5, Bases.MAX_PRIORITY);
 17: assertEquals(2, Bases.REVERSE);
 18: assertEquals(0, Bases.MEDIUM_PRIORITY);
 19: assertEquals(1, Bases.FORWARD);
 20: assertEquals((-5), Bases.MIN_PRIORITY);
 21: assertNotNull(simpleEntryGroup0);
 22: assertEquals(0, simpleEntryGroup0.refCount());
 23: assertEquals(0, simpleEntryGroup0.size());
 24: 
 25: simpleEntryGroup0.createFeature();

Test case 65

  1: int int0 = AminoAcidSequence.getAminoAcidType('W');
  2: assertEquals(3, int0);
  3: 
  4: char char0 = AminoAcidSequence.getCodonTranslation("$wnN%/2eaL^A");
  5: assertEquals('.', char0);
  6: 
  7: int int1 = AminoAcidSequence.getSymbolIndex('W');
  8: assertFalse(int1 == int0);
  9: assertEquals(17, int1);
 10: 
 11: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('d');
 12: assertEquals("Asp", string0);
 13: assertNotNull(string0);
 14: 
 15: String string1 = AminoAcidSequence.getThreeLetterAbbreviation(17);
 16: assertFalse(string1.equals((Object)string0));
 17: assertEquals("Trp", string1);
 18: assertNotNull(string1);
 19: 
 20: AminoAcidSequence.setGeneCode();
 21: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("eOBx", true);
 22: assertEquals(25, AminoAcidSequence.symbol_count);
 23: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 24: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertEquals(5, AminoAcidSequence.STOP_AA);
 27: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 28: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 29: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertNotNull(aminoAcidSequence0);
 32: assertEquals(1, aminoAcidSequence0.length());
 33: assertFalse(aminoAcidSequence0.containsStopCodon());
 34: assertEquals("x", aminoAcidSequence0.toString());
 35: 
 36: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Asp", true);
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 39: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 40: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 41: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 42: assertEquals(5, AminoAcidSequence.STOP_AA);
 43: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 44: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 45: assertEquals(25, AminoAcidSequence.symbol_count);
 46: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 47: assertNotNull(aminoAcidSequence1);
 48: assertEquals("x  ", aminoAcidSequence1.toString());
 49: assertFalse(aminoAcidSequence1.containsStopCodon());
 50: assertEquals(3, aminoAcidSequence1.length());
 51: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 52: 
 53: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 54: assertEquals(25, AminoAcidSequence.symbol_count);
 55: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 56: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 57: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 58: assertEquals(5, AminoAcidSequence.STOP_AA);
 59: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 60: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 61: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 62: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 63: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 64: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 65: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 66: assertEquals(25, AminoAcidSequence.symbol_count);
 67: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 68: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 69: assertEquals(5, AminoAcidSequence.STOP_AA);
 70: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 71: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 72: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 73: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 74: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 75: assertNotNull(aminoAcidSequence2);
 76: assertEquals(1, aminoAcidSequence0.length());
 77: assertFalse(aminoAcidSequence0.containsStopCodon());
 78: assertEquals("x", aminoAcidSequence0.toString());
 79: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence2.toString());
 80: assertEquals(21, aminoAcidSequence2.length());
 81: assertFalse(aminoAcidSequence2.containsStopCodon());
 82: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 83: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 84: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 85: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 86: 
 87: AminoAcidSequence.setGeneCode();
 88: boolean boolean0 = aminoAcidSequence0.containsStopCodon();
 89: assertEquals(25, AminoAcidSequence.symbol_count);
 90: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 91: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 92: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 93: assertEquals(5, AminoAcidSequence.STOP_AA);
 94: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 95: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 96: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 97: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 98: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
 99: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
100: assertFalse(boolean0);
101: assertEquals(1, aminoAcidSequence0.length());
102: assertFalse(aminoAcidSequence0.containsStopCodon());
103: assertEquals("x", aminoAcidSequence0.toString());
104: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
105: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
106: 
107: GenbankStreamFeature genbankStreamFeature0 = new GenbankStreamFeature();
108: assertNotNull(genbankStreamFeature0);
109: 
110: Feature feature0 = new Feature(genbankStreamFeature0);
111: assertNotNull(feature0);
112: assertFalse(feature0.isReadOnly());

Test case 66

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(")96t6[|:Ku3 F;)KJz", true);
  2: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  3: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  4: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  8: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  9: assertEquals(25, AminoAcidSequence.symbol_count);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals("xxxxxx", aminoAcidSequence0.toString());
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals(6, aminoAcidSequence0.length());
 15: 
 16: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 17: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 18: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 19: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(5, AminoAcidSequence.STOP_AA);
 22: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 23: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 24: assertEquals(25, AminoAcidSequence.symbol_count);
 25: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 26: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 27: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 28: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 29: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 30: assertEquals(5, AminoAcidSequence.STOP_AA);
 31: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 32: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 33: assertEquals(25, AminoAcidSequence.symbol_count);
 34: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 35: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 36: assertNotNull(aminoAcidSequence1);
 37: assertEquals("xxxxxx", aminoAcidSequence0.toString());
 38: assertFalse(aminoAcidSequence0.containsStopCodon());
 39: assertEquals(6, aminoAcidSequence0.length());
 40: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
 41: assertFalse(aminoAcidSequence1.containsStopCodon());
 42: assertEquals(21, aminoAcidSequence1.length());
 43: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 44: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 45: 
 46: String string0 = aminoAcidSequence0.toString();
 47: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 48: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 49: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 50: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 51: assertEquals(5, AminoAcidSequence.STOP_AA);
 52: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 53: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 54: assertEquals(25, AminoAcidSequence.symbol_count);
 55: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 56: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 57: assertEquals("xxxxxx", string0);
 58: assertNotNull(string0);
 59: assertEquals("xxxxxx", aminoAcidSequence0.toString());
 60: assertFalse(aminoAcidSequence0.containsStopCodon());
 61: assertEquals(6, aminoAcidSequence0.length());
 62: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 63: 
 64: boolean boolean0 = aminoAcidSequence0.containsStopCodon();
 65: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 66: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 67: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 68: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 69: assertEquals(5, AminoAcidSequence.STOP_AA);
 70: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 71: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 72: assertEquals(25, AminoAcidSequence.symbol_count);
 73: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 74: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 75: assertFalse(boolean0);
 76: assertEquals("xxxxxx", aminoAcidSequence0.toString());
 77: assertFalse(aminoAcidSequence0.containsStopCodon());
 78: assertEquals(6, aminoAcidSequence0.length());
 79: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 80: 
 81: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation("xxxxxx", false);
 82: assertEquals(5, AminoAcidSequence.STOP_AA);
 83: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 84: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 85: assertEquals(25, AminoAcidSequence.symbol_count);
 86: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 87: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 88: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 89: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 90: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 91: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 92: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 93: assertNotNull(aminoAcidSequence2);
 94: assertEquals("..", aminoAcidSequence2.toString());
 95: assertEquals(2, aminoAcidSequence2.length());
 96: assertFalse(aminoAcidSequence2.containsStopCodon());
 97: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 98: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 99: 
100: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, true);
101: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
102: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
103: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
104: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
105: assertEquals(5, AminoAcidSequence.STOP_AA);
106: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
107: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
108: assertEquals(25, AminoAcidSequence.symbol_count);
109: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
110: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
111: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
112: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
113: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
114: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
115: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
116: assertEquals(25, AminoAcidSequence.symbol_count);
117: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
118: assertEquals(5, AminoAcidSequence.STOP_AA);
119: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
120: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
121: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
122: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
123: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
124: assertNotNull(aminoAcidSequence3);
125: assertEquals("xxxxxx", aminoAcidSequence0.toString());
126: assertFalse(aminoAcidSequence0.containsStopCodon());
127: assertEquals(6, aminoAcidSequence0.length());
128: assertEquals(63, aminoAcidSequence3.length());
129: assertFalse(aminoAcidSequence3.containsStopCodon());
130: assertEquals("x  x  x  x  x  x  x  x  x  x  x  x  f  x  x  x  x  x  x  x  g  ", aminoAcidSequence3.toString());
131: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
132: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
133: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
134: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
135: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
136: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
137: 
138: int int0 = AminoAcidSequence.getSymbolIndex('p');
139: assertEquals(14, int0);
140: 
141: int int1 = AminoAcidSequence.getSymbolIndex('l');
142: assertFalse(int1 == int0);
143: assertEquals(10, int1);
144: 
145: aminoAcidSequence0.elementAt(980);

Test case 67

  1: int int0 = AminoAcidSequence.getAminoAcidType('/');
  2: assertEquals(7, int0);
  3: 
  4: AminoAcidSequence.setGeneCode();
  5: AminoAcidSequence.getThreeLetterAbbreviation('/');

Test case 68

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("%i;Cw");
  2: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  3: assertEquals(5, AminoAcidSequence.STOP_AA);
  4: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  5: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  8: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(5, aminoAcidSequence0.length());
 13: assertEquals("%i;Cw", aminoAcidSequence0.toString());
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: 
 16: aminoAcidSequence0.getMolecularWeight();

Test case 69

  1: int int0 = AminoAcidSequence.getAminoAcidType('O');
  2: assertEquals(7, int0);
  3: 
  4: AminoAcidSequence.setGeneCode();

Test case 70

  1: boolean boolean0 = AminoAcidSequence.isStopCodon('x');
  2: assertFalse(boolean0);
  3: 
  4: int int0 = AminoAcidSequence.getAminoAcidType('=');
  5: assertEquals(7, int0);
  6: 
  7: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  8: assertNotNull(simpleEntryGroup0);
  9: assertEquals(0, simpleEntryGroup0.size());
 10: assertEquals(0, simpleEntryGroup0.refCount());
 11: 
 12: FeatureVector featureVector0 = new FeatureVector();
 13: assertNotNull(featureVector0);
 14: 
 15: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureVector0, "Cn=0");
 16: assertNotNull(filteredEntryGroup0);
 17: assertEquals(0, simpleEntryGroup0.size());
 18: assertEquals(0, simpleEntryGroup0.refCount());
 19: assertEquals(0, filteredEntryGroup0.size());
 20: assertEquals(0, filteredEntryGroup0.refCount());
 21: assertEquals("Cn=0", filteredEntryGroup0.getFilterName());
 22: 
 23: Clipboard clipboard0 = new Clipboard((String) null);
 24: assertNotNull(clipboard0);
 25: assertNull(clipboard0.getName());
 26: 
 27: Selection selection0 = new Selection(clipboard0);
 28: assertNotNull(selection0);
 29: assertNull(clipboard0.getName());
 30: 
 31: DefaultTableCellRenderer.UIResource defaultTableCellRenderer_UIResource0 = new DefaultTableCellRenderer.UIResource();
 32: assertNotNull(defaultTableCellRenderer_UIResource0);
 33: assertTrue(defaultTableCellRenderer_UIResource0.getFocusTraversalKeysEnabled());
 34: assertFalse(defaultTableCellRenderer_UIResource0.getIgnoreRepaint());
 35: assertFalse(defaultTableCellRenderer_UIResource0.isFocusTraversalPolicySet());
 36: assertFalse(defaultTableCellRenderer_UIResource0.isFocusCycleRoot());
 37: assertFalse(defaultTableCellRenderer_UIResource0.isFocusTraversalPolicyProvider());
 38: 
 39: BasePlotGroup basePlotGroup0 = new BasePlotGroup(filteredEntryGroup0, defaultTableCellRenderer_UIResource0, selection0, (GotoEventSource) null);

Test case 71

  1: boolean boolean0 = AminoAcidSequence.isStopCodon('+');
  2: assertTrue(boolean0);
  3: 
  4: AminoAcidSequence.setGeneCode();
  5: AminoAcidSequence.getThreeLetterAbbreviation(766);

Test case 72

  1: AminoAcidSequence.setGeneCode();
  2: char char0 = AminoAcidSequence.getCodonTranslation('2', '2', '2');
  3: assertEquals('.', char0);
  4: 
  5: boolean boolean0 = AminoAcidSequence.isLegalCodon('2');
  6: assertFalse(boolean0);

Test case 73

  1: char[] charArray0 = new char[9];
  2: charArray0[0] = '<';
  3: charArray0[1] = '<';
  4: charArray0[3] = 'X';
  5: charArray0[4] = 'D';
  6: charArray0[5] = 'K';
  7: charArray0[6] = 'w';
  8: charArray0[7] = '<';
  9: charArray0[8] = 'i';
 10: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
 11: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 12: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 15: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 16: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 17: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 18: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 19: assertEquals(5, AminoAcidSequence.STOP_AA);
 20: assertArrayEquals(new char[] {'<', '<', '\u0000', 'X', 'D', 'K', 'w', '<', 'i'}, charArray0);
 21: assertNotNull(aminoAcidSequence0);
 22: assertFalse(aminoAcidSequence0.containsStopCodon());
 23: assertEquals(3, aminoAcidSequence0.length());
 24: assertEquals("xxx", aminoAcidSequence0.toString());
 25: 
 26: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 27: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 28: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 29: assertEquals(25, AminoAcidSequence.symbol_count);
 30: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 31: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 32: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 33: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 34: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 35: assertEquals(5, AminoAcidSequence.STOP_AA);
 36: assertEquals(25, AminoAcidSequence.symbol_count);
 37: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 38: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 39: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 40: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 41: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 42: assertEquals(5, AminoAcidSequence.STOP_AA);
 43: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 44: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 45: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 46: assertArrayEquals(new char[] {'<', '<', '\u0000', 'X', 'D', 'K', 'w', '<', 'i'}, charArray0);
 47: assertNotNull(aminoAcidSequence1);
 48: assertFalse(aminoAcidSequence0.containsStopCodon());
 49: assertEquals(3, aminoAcidSequence0.length());
 50: assertEquals("xxx", aminoAcidSequence0.toString());
 51: assertFalse(aminoAcidSequence1.containsStopCodon());
 52: assertEquals(21, aminoAcidSequence1.length());
 53: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
 54: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 55: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 56: 
 57: float float0 = aminoAcidSequence0.getMolecularWeight();
 58: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 59: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 60: assertEquals(25, AminoAcidSequence.symbol_count);
 61: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 62: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 63: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 64: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 65: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 66: assertEquals(5, AminoAcidSequence.STOP_AA);
 67: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 68: assertEquals((-36.03F), float0, 0.01F);
 69: assertArrayEquals(new char[] {'<', '<', '\u0000', 'X', 'D', 'K', 'w', '<', 'i'}, charArray0);
 70: assertFalse(aminoAcidSequence0.containsStopCodon());
 71: assertEquals(3, aminoAcidSequence0.length());
 72: assertEquals("xxx", aminoAcidSequence0.toString());
 73: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 74: 
 75: char char0 = AminoAcidSequence.getOneLetterCode("th>9RQLD");
 76: assertEquals('\uFFFF', char0);
 77: 
 78: int int0 = AminoAcidSequence.getAminoAcidType('?');
 79: assertEquals(7, int0);
 80: 
 81: float float1 = aminoAcidSequence0.getMolecularWeight();
 82: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 83: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 84: assertEquals(25, AminoAcidSequence.symbol_count);
 85: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 86: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 87: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 88: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 89: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 90: assertEquals(5, AminoAcidSequence.STOP_AA);
 91: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 92: assertEquals(float1, float0, 0.01F);
 93: assertEquals((-36.03F), float1, 0.01F);
 94: assertArrayEquals(new char[] {'<', '<', '\u0000', 'X', 'D', 'K', 'w', '<', 'i'}, charArray0);
 95: assertFalse(aminoAcidSequence0.containsStopCodon());
 96: assertEquals(3, aminoAcidSequence0.length());
 97: assertEquals("xxx", aminoAcidSequence0.toString());
 98: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 99: 
100: float float2 = aminoAcidSequence1.getMolecularWeight();
101: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
102: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
103: assertEquals(25, AminoAcidSequence.symbol_count);
104: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
105: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
106: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
107: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
108: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
109: assertEquals(5, AminoAcidSequence.STOP_AA);
110: assertEquals(25, AminoAcidSequence.symbol_count);
111: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
112: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
113: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
114: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
115: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
116: assertEquals(5, AminoAcidSequence.STOP_AA);
117: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
118: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
119: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
120: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
121: assertNotEquals(float2, float1, 0.01F);
122: assertNotEquals(float2, float0, 0.01F);
123: assertEquals((-120.03998F), float2, 0.01F);
124: assertArrayEquals(new char[] {'<', '<', '\u0000', 'X', 'D', 'K', 'w', '<', 'i'}, charArray0);
125: assertFalse(aminoAcidSequence0.containsStopCodon());
126: assertEquals(3, aminoAcidSequence0.length());
127: assertEquals("xxx", aminoAcidSequence0.toString());
128: assertFalse(aminoAcidSequence1.containsStopCodon());
129: assertEquals(21, aminoAcidSequence1.length());
130: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
131: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
132: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);

Test case 74

  1: char char0 = AminoAcidSequence.getCodonTranslation("---");
  2: assertEquals('.', char0);
  3: 
  4: int int0 = AminoAcidSequence.getSymbolIndex('*');
  5: assertEquals(20, int0);
  6: 
  7: char char1 = AminoAcidSequence.getCodonTranslation("---");
  8: assertTrue(char1 == char0);
  9: assertEquals('.', char1);
 10: 
 11: int int1 = AminoAcidSequence.getSymbolIndex('*');
 12: assertTrue(int1 == int0);
 13: assertEquals(20, int1);
 14: 
 15: char char2 = AminoAcidSequence.getCodonTranslation(']', '!', '\"');
 16: assertTrue(char2 == char0);
 17: assertTrue(char2 == char1);
 18: assertEquals('.', char2);

Test case 75

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("S&Dipm<2K", false);
  2: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  3: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  4: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  5: assertEquals(25, AminoAcidSequence.symbol_count);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 10: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(".  .  .  ", aminoAcidSequence0.toString());
 13: assertEquals(9, aminoAcidSequence0.length());
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: 
 16: AminoAcidSequence.setGeneCode();
 17: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 18: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 19: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 20: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 21: assertEquals(25, AminoAcidSequence.symbol_count);
 22: assertEquals(5, AminoAcidSequence.STOP_AA);
 23: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 24: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 25: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 26: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 27: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 28: assertEquals(25, AminoAcidSequence.symbol_count);
 29: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 30: assertEquals(5, AminoAcidSequence.STOP_AA);
 31: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 32: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 33: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 34: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 35: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 36: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 37: assertNotNull(aminoAcidSequence1);
 38: assertEquals(".  .  .  ", aminoAcidSequence0.toString());
 39: assertEquals(9, aminoAcidSequence0.length());
 40: assertFalse(aminoAcidSequence0.containsStopCodon());
 41: assertEquals(21, aminoAcidSequence1.length());
 42: assertEquals("............f.......g", aminoAcidSequence1.toString());
 43: assertFalse(aminoAcidSequence1.containsStopCodon());
 44: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 45: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 46: 
 47: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, false);
 48: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 49: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 50: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 51: assertEquals(25, AminoAcidSequence.symbol_count);
 52: assertEquals(5, AminoAcidSequence.STOP_AA);
 53: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 54: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 55: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 56: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 57: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 58: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 59: assertEquals(25, AminoAcidSequence.symbol_count);
 60: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 61: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 62: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 63: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 64: assertEquals(5, AminoAcidSequence.STOP_AA);
 65: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 66: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 67: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 68: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 69: assertNotNull(aminoAcidSequence2);
 70: assertEquals(".  .  .  ", aminoAcidSequence0.toString());
 71: assertEquals(9, aminoAcidSequence0.length());
 72: assertFalse(aminoAcidSequence0.containsStopCodon());
 73: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence2.toString());
 74: assertEquals(63, aminoAcidSequence2.length());
 75: assertFalse(aminoAcidSequence2.containsStopCodon());
 76: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 77: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 78: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 79: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 80: 
 81: int int0 = AminoAcidSequence.getSymbolIndex('q');
 82: assertEquals(5, int0);
 83: 
 84: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("S&Dipm<2K", true);
 85: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 86: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 87: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 88: assertEquals(25, AminoAcidSequence.symbol_count);
 89: assertEquals(5, AminoAcidSequence.STOP_AA);
 90: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 91: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 92: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 93: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 94: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 95: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 96: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 97: assertNotNull(aminoAcidSequence3);
 98: assertEquals("xxx", aminoAcidSequence3.toString());
 99: assertEquals(3, aminoAcidSequence3.length());
100: assertFalse(aminoAcidSequence3.containsStopCodon());
101: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
102: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
103: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
104: 
105: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('r');
106: assertEquals("Arg", string0);
107: assertNotNull(string0);
108: 
109: char char0 = AminoAcidSequence.getOneLetterCode("6\"N_OP&i+");
110: assertEquals('\uFFFF', char0);
111: 
112: aminoAcidSequence0.getMolecularWeight();

Test case 76

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('K');
  2: assertTrue(boolean0);
  3: 
  4: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  5: assertNotNull(simpleEntryGroup0);
  6: assertEquals(0, simpleEntryGroup0.refCount());
  7: assertEquals(0, simpleEntryGroup0.size());
  8: 
  9: Selection selection0 = new Selection((Clipboard) null);
 10: assertNotNull(selection0);
 11: 
 12: JScrollBar jScrollBar0 = new JScrollBar();
 13: assertNotNull(jScrollBar0);
 14: assertFalse(jScrollBar0.isFocusCycleRoot());
 15: assertFalse(jScrollBar0.getIgnoreRepaint());
 16: assertTrue(jScrollBar0.getFocusTraversalKeysEnabled());
 17: assertFalse(jScrollBar0.isFocusTraversalPolicySet());
 18: assertFalse(jScrollBar0.isFocusTraversalPolicyProvider());
 19: 
 20: BasePlotGroup basePlotGroup0 = new BasePlotGroup(simpleEntryGroup0, jScrollBar0, selection0, (GotoEventSource) null);

Test case 77

  1: char[] charArray0 = new char[6];
  2: charArray0[0] = 'O';
  3: charArray0[1] = 'd';
  4: charArray0[2] = '2';
  5: charArray0[3] = '=';
  6: charArray0[4] = 'A';
  7: charArray0[5] = 'z';
  8: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
  9: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 10: assertEquals(5, AminoAcidSequence.STOP_AA);
 11: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 12: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 13: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 14: assertEquals(25, AminoAcidSequence.symbol_count);
 15: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 16: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 17: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 18: assertArrayEquals(new char[] {'O', 'd', '2', '=', 'A', 'z'}, charArray0);
 19: assertNotNull(aminoAcidSequence0);
 20: assertEquals(2, aminoAcidSequence0.length());
 21: assertFalse(aminoAcidSequence0.containsStopCodon());
 22: assertEquals("xx", aminoAcidSequence0.toString());
 23: 
 24: AminoAcidSequence.setGeneCode();
 25: AminoAcidSequence.setGeneCode();
 26: char char0 = AminoAcidSequence.getCodonTranslation('J', 'd', 'J');
 27: assertEquals('.', char0);
 28: 
 29: int int0 = AminoAcidSequence.getSymbolIndex('A');
 30: assertEquals(0, int0);
 31: 
 32: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("", true);
 33: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 34: assertEquals(25, AminoAcidSequence.symbol_count);
 35: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 36: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 37: assertEquals(5, AminoAcidSequence.STOP_AA);
 38: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 39: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 40: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 41: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 42: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 43: assertNotNull(aminoAcidSequence1);
 44: assertEquals("", aminoAcidSequence1.toString());
 45: assertFalse(aminoAcidSequence1.containsStopCodon());
 46: assertEquals(0, aminoAcidSequence1.length());
 47: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 48: 
 49: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 50: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 51: assertEquals(5, AminoAcidSequence.STOP_AA);
 52: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 53: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 54: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 55: assertEquals(25, AminoAcidSequence.symbol_count);
 56: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 57: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 58: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 59: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 60: assertEquals(5, AminoAcidSequence.STOP_AA);
 61: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 62: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 63: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 64: assertEquals(25, AminoAcidSequence.symbol_count);
 65: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 66: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 67: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 68: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 69: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 70: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 71: assertArrayEquals(new char[] {'O', 'd', '2', '=', 'A', 'z'}, charArray0);
 72: assertNotNull(aminoAcidSequence2);
 73: assertEquals(2, aminoAcidSequence0.length());
 74: assertFalse(aminoAcidSequence0.containsStopCodon());
 75: assertEquals("xx", aminoAcidSequence0.toString());
 76: assertEquals(21, aminoAcidSequence2.length());
 77: assertFalse(aminoAcidSequence2.containsStopCodon());
 78: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence2.toString());
 79: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 80: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 81: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 82: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 83: 
 84: AminoAcidSequence.getThreeLetterAbbreviation(' ');

Test case 78

  1: AminoAcidSequence.setGeneCode();
  2: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Thr", false);
  3: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  4: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  5: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(5, AminoAcidSequence.STOP_AA);
  8: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  9: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 10: assertEquals(25, AminoAcidSequence.symbol_count);
 11: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 12: assertNotNull(aminoAcidSequence0);
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals(".", aminoAcidSequence0.toString());
 15: assertEquals(1, aminoAcidSequence0.length());
 16: 
 17: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("Thr", true);
 18: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 19: assertEquals(5, AminoAcidSequence.STOP_AA);
 20: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 21: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 22: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 23: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 24: assertEquals(25, AminoAcidSequence.symbol_count);
 25: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 26: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 27: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 28: assertNotNull(aminoAcidSequence1);
 29: assertEquals("x", aminoAcidSequence1.toString());
 30: assertEquals(1, aminoAcidSequence1.length());
 31: assertFalse(aminoAcidSequence1.containsStopCodon());
 32: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 33: 
 34: aminoAcidSequence0.checkForMatch((AminoAcidSequence) null);

Test case 79

  1: String string0 = JColorChooser.CHOOSER_PANELS_PROPERTY;
  2: assertEquals("chooserPanels", string0);
  3: assertNotNull(string0);
  4: 
  5: int int0 = AminoAcidSequence.getAminoAcidType('@');
  6: assertEquals(7, int0);
  7: 
  8: char char0 = AminoAcidSequence.getCodonTranslation("");
  9: assertEquals('.', char0);
 10: 
 11: AminoAcidSequence.getSymbolFromIndex(1747);

Test case 80

  1: int int0 = AminoAcidSequence.getAminoAcidType('X');
  2: assertEquals(7, int0);
  3: 
  4: boolean boolean0 = AminoAcidSequence.isStopCodon('5');
  5: assertFalse(boolean0);

Test case 81

  1: String string0 = VCFHeader.METADATA_INDICATOR;
  2: assertEquals("##", string0);
  3: assertNotNull(string0);
  4: 
  5: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("##");
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  8: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  9: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 10: assertEquals(5, AminoAcidSequence.STOP_AA);
 11: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 12: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 13: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 14: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 15: assertNotNull(aminoAcidSequence0);
 16: assertEquals("##", aminoAcidSequence0.toString());
 17: assertTrue(aminoAcidSequence0.containsStopCodon());
 18: assertEquals(2, aminoAcidSequence0.length());
 19: 
 20: int int0 = AminoAcidSequence.getAminoAcidType('X');
 21: assertEquals(7, int0);
 22: 
 23: boolean boolean0 = AminoAcidSequence.isStopCodon('5');
 24: assertFalse(boolean0);
 25: 
 26: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, false);
 27: assertEquals(25, AminoAcidSequence.symbol_count);
 28: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 29: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertEquals(5, AminoAcidSequence.STOP_AA);
 32: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 33: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 34: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 35: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 36: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 37: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 38: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 39: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 40: assertEquals(25, AminoAcidSequence.symbol_count);
 41: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 42: assertEquals(5, AminoAcidSequence.STOP_AA);
 43: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 44: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 45: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 46: assertNotNull(aminoAcidSequence1);
 47: assertEquals("##", aminoAcidSequence0.toString());
 48: assertTrue(aminoAcidSequence0.containsStopCodon());
 49: assertEquals(2, aminoAcidSequence0.length());
 50: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence1.toString());
 51: assertEquals(63, aminoAcidSequence1.length());
 52: assertFalse(aminoAcidSequence1.containsStopCodon());
 53: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 54: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 55: 
 56: char char0 = aminoAcidSequence1.elementAt(7);
 57: assertEquals(25, AminoAcidSequence.symbol_count);
 58: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 59: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 60: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 61: assertEquals(5, AminoAcidSequence.STOP_AA);
 62: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 63: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 64: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 65: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 66: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 67: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 68: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 69: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 70: assertEquals(25, AminoAcidSequence.symbol_count);
 71: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 72: assertEquals(5, AminoAcidSequence.STOP_AA);
 73: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 74: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 75: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 76: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 77: assertEquals(' ', char0);
 78: assertEquals("##", aminoAcidSequence0.toString());
 79: assertTrue(aminoAcidSequence0.containsStopCodon());
 80: assertEquals(2, aminoAcidSequence0.length());
 81: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence1.toString());
 82: assertEquals(63, aminoAcidSequence1.length());
 83: assertFalse(aminoAcidSequence1.containsStopCodon());
 84: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 85: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);

Test case 82

  1: int int0 = AminoAcidSequence.getAminoAcidType('0');
  2: assertEquals(7, int0);
  3: 
  4: AminoAcidSequence.getTranslation((char[]) null, false);

Test case 83

  1: int int0 = AminoAcidSequence.getSymbolIndex('M');
  2: assertEquals(12, int0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("", true);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  8: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  9: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 10: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 11: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 12: assertEquals(5, AminoAcidSequence.STOP_AA);
 13: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 14: assertNotNull(aminoAcidSequence0);
 15: assertFalse(aminoAcidSequence0.containsStopCodon());
 16: assertEquals(0, aminoAcidSequence0.length());
 17: assertEquals("", aminoAcidSequence0.toString());
 18: 
 19: int int1 = AminoAcidSequence.getAminoAcidType('e');
 20: assertFalse(int1 == int0);
 21: assertEquals(7, int1);
 22: 
 23: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 24: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 25: assertEquals(25, AminoAcidSequence.symbol_count);
 26: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 27: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 28: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 29: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertEquals(5, AminoAcidSequence.STOP_AA);
 32: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 33: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 34: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 35: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 36: assertEquals(5, AminoAcidSequence.STOP_AA);
 37: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 38: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 39: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 40: assertEquals(25, AminoAcidSequence.symbol_count);
 41: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 42: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 43: assertNotNull(aminoAcidSequence1);
 44: assertFalse(aminoAcidSequence0.containsStopCodon());
 45: assertEquals(0, aminoAcidSequence0.length());
 46: assertEquals("", aminoAcidSequence0.toString());
 47: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
 48: assertFalse(aminoAcidSequence1.containsStopCodon());
 49: assertEquals(21, aminoAcidSequence1.length());
 50: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 51: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 52: 
 53: int int2 = AminoAcidSequence.getSymbolIndex('e');
 54: assertFalse(int2 == int0);
 55: assertFalse(int2 == int1);
 56: assertEquals(6, int2);

Test case 84

  1: AminoAcidSequence.setGeneCode();
  2: char[] charArray0 = new char[9];
  3: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
  4: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  5: assertEquals(5, AminoAcidSequence.STOP_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  8: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  9: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 12: assertEquals(25, AminoAcidSequence.symbol_count);
 13: assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals(9, aminoAcidSequence0.length());
 16: assertFalse(aminoAcidSequence0.containsStopCodon());
 17: assertEquals("x  x  x  ", aminoAcidSequence0.toString());
 18: 
 19: charArray0[0] = '$';
 20: charArray0[1] = 'f';
 21: charArray0[2] = 'n';
 22: charArray0[3] = '\\';
 23: charArray0[4] = '>';
 24: charArray0[5] = 'h';
 25: charArray0[6] = 'v';
 26: charArray0[7] = '>';
 27: charArray0[8] = 'V';
 28: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation(charArray0, false);
 29: assertEquals(5, AminoAcidSequence.STOP_AA);
 30: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 31: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 32: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 33: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 34: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 35: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 36: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 37: assertEquals(25, AminoAcidSequence.symbol_count);
 38: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 39: assertArrayEquals(new char[] {'$', 'f', 'n', '\\', '>', 'h', 'v', '>', 'V'}, charArray0);
 40: assertNotNull(aminoAcidSequence1);
 41: assertEquals(9, aminoAcidSequence1.length());
 42: assertFalse(aminoAcidSequence1.containsStopCodon());
 43: assertEquals(".  .  .  ", aminoAcidSequence1.toString());
 44: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 45: 
 46: boolean boolean0 = AminoAcidSequence.isLegalCodon('?');
 47: assertFalse(boolean0);
 48: 
 49: aminoAcidSequence0.elementAt(25);

Test case 85

  1: int int0 = AminoAcidSequence.getAminoAcidType('9');
  2: assertEquals(7, int0);

Test case 86

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("org.biojava.bio.symbol.AbstractSymbolList$SubList");
  2: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  3: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  4: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  5: assertEquals(5, AminoAcidSequence.STOP_AA);
  6: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  7: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  8: assertEquals(25, AminoAcidSequence.symbol_count);
  9: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(49, aminoAcidSequence0.length());
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals("org.biojava.bio.symbol.AbstractSymbolList$SubList", aminoAcidSequence0.toString());
 15: 
 16: char[] charArray0 = new char[4];
 17: charArray0[1] = 'M';
 18: charArray0[2] = 'y';
 19: charArray0[3] = '[';
 20: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 21: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 22: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 23: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 24: assertEquals(5, AminoAcidSequence.STOP_AA);
 25: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 26: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 27: assertEquals(25, AminoAcidSequence.symbol_count);
 28: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 29: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 30: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 31: assertEquals(5, AminoAcidSequence.STOP_AA);
 32: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 33: assertEquals(25, AminoAcidSequence.symbol_count);
 34: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 35: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 36: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 37: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 38: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 39: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 40: assertNotNull(aminoAcidSequence1);
 41: assertEquals(49, aminoAcidSequence0.length());
 42: assertFalse(aminoAcidSequence0.containsStopCodon());
 43: assertEquals("org.biojava.bio.symbol.AbstractSymbolList$SubList", aminoAcidSequence0.toString());
 44: assertEquals(21, aminoAcidSequence1.length());
 45: assertFalse(aminoAcidSequence1.containsStopCodon());
 46: assertEquals("............f.......g", aminoAcidSequence1.toString());
 47: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 48: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 49: 
 50: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(charArray0, false);
 51: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 52: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 53: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 54: assertEquals(5, AminoAcidSequence.STOP_AA);
 55: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 56: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 57: assertEquals(25, AminoAcidSequence.symbol_count);
 58: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 59: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 60: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 61: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 62: assertArrayEquals(new char[] {'\u0000', 'M', 'y', '['}, charArray0);
 63: assertNotNull(aminoAcidSequence2);
 64: assertEquals(3, aminoAcidSequence2.length());
 65: assertFalse(aminoAcidSequence2.containsStopCodon());
 66: assertEquals(".  ", aminoAcidSequence2.toString());
 67: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 68: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 69: 
 70: char char0 = aminoAcidSequence0.elementAt(0);
 71: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 72: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 73: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 74: assertEquals(5, AminoAcidSequence.STOP_AA);
 75: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 76: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 77: assertEquals(25, AminoAcidSequence.symbol_count);
 78: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 79: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 80: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
 81: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 82: assertEquals('o', char0);
 83: assertEquals(49, aminoAcidSequence0.length());
 84: assertFalse(aminoAcidSequence0.containsStopCodon());
 85: assertEquals("org.biojava.bio.symbol.AbstractSymbolList$SubList", aminoAcidSequence0.toString());
 86: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 87: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);

Test case 87

  1: int int0 = AminoAcidSequence.getAminoAcidType('(');
  2: assertEquals(7, int0);

Test case 88

  1: char[] charArray0 = new char[0];
  2: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, false);
  3: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  4: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  5: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  6: assertEquals(5, AminoAcidSequence.STOP_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(25, AminoAcidSequence.symbol_count);
 11: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 12: assertArrayEquals(new char[] {}, charArray0);
 13: assertNotNull(aminoAcidSequence0);
 14: assertEquals(0, aminoAcidSequence0.length());
 15: assertFalse(aminoAcidSequence0.containsStopCodon());
 16: assertEquals("", aminoAcidSequence0.toString());
 17: 
 18: int int0 = AminoAcidSequence.getSymbolIndex('U');
 19: assertEquals(24, int0);
 20: 
 21: char char0 = File.separatorChar;
 22: assertEquals('/', char0);
 23: 
 24: int int1 = aminoAcidSequence0.length();
 25: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 26: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 27: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 28: assertEquals(5, AminoAcidSequence.STOP_AA);
 29: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 30: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 31: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 32: assertEquals(25, AminoAcidSequence.symbol_count);
 33: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 34: assertFalse(int1 == int0);
 35: assertEquals(0, int1);
 36: assertArrayEquals(new char[] {}, charArray0);
 37: assertEquals(0, aminoAcidSequence0.length());
 38: assertFalse(aminoAcidSequence0.containsStopCodon());
 39: assertEquals("", aminoAcidSequence0.toString());
 40: 
 41: boolean boolean0 = AminoAcidSequence.isLegalCodon('\'');
 42: assertFalse(boolean0);
 43: 
 44: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 45: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 46: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 47: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 48: assertEquals(5, AminoAcidSequence.STOP_AA);
 49: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 50: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 51: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 52: assertEquals(25, AminoAcidSequence.symbol_count);
 53: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 54: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 55: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 56: assertEquals(25, AminoAcidSequence.symbol_count);
 57: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 58: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 59: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 60: assertEquals(5, AminoAcidSequence.STOP_AA);
 61: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 62: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 63: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 64: assertArrayEquals(new char[] {}, charArray0);
 65: assertNotNull(aminoAcidSequence1);
 66: assertEquals(0, aminoAcidSequence0.length());
 67: assertFalse(aminoAcidSequence0.containsStopCodon());
 68: assertEquals("", aminoAcidSequence0.toString());
 69: assertEquals("............f.......g", aminoAcidSequence1.toString());
 70: assertFalse(aminoAcidSequence1.containsStopCodon());
 71: assertEquals(21, aminoAcidSequence1.length());
 72: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 73: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 74: 
 75: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation("", false);
 76: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 77: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 78: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 79: assertEquals(25, AminoAcidSequence.symbol_count);
 80: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 81: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 82: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 83: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 84: assertEquals(5, AminoAcidSequence.STOP_AA);
 85: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 86: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 87: assertNotNull(aminoAcidSequence2);
 88: assertFalse(aminoAcidSequence2.containsStopCodon());
 89: assertEquals(0, aminoAcidSequence2.length());
 90: assertEquals("", aminoAcidSequence2.toString());
 91: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 92: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 93: 
 94: AminoAcidSequence.setGeneCode();
 95: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('u');
 96: assertEquals("Sel", string0);
 97: assertNotNull(string0);
 98: 
 99: boolean boolean1 = aminoAcidSequence0.containsStopCodon();
100: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
101: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
102: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
103: assertEquals(5, AminoAcidSequence.STOP_AA);
104: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
105: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
106: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
107: assertEquals(25, AminoAcidSequence.symbol_count);
108: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
109: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
110: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
111: assertTrue(boolean1 == boolean0);
112: assertFalse(boolean1);
113: assertArrayEquals(new char[] {}, charArray0);
114: assertEquals(0, aminoAcidSequence0.length());
115: assertFalse(aminoAcidSequence0.containsStopCodon());
116: assertEquals("", aminoAcidSequence0.toString());
117: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
118: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
119: 
120: char char1 = AminoAcidSequence.getCodonTranslation('u', 'w', '/');
121: assertFalse(char1 == char0);
122: assertEquals('.', char1);
123: 
124: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getSpacedTranslation("", true);
125: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
126: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
127: assertEquals(5, AminoAcidSequence.STOP_AA);
128: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
129: assertEquals(25, AminoAcidSequence.symbol_count);
130: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
131: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
132: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
133: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
134: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
135: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
136: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
137: assertNotNull(aminoAcidSequence3);
138: assertEquals("", aminoAcidSequence3.toString());
139: assertEquals(0, aminoAcidSequence3.length());
140: assertFalse(aminoAcidSequence3.containsStopCodon());
141: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
142: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
143: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
144: 
145: boolean boolean2 = AminoAcidSequence.isLegalCodon('l');
146: assertFalse(boolean2 == boolean1);
147: assertFalse(boolean2 == boolean0);
148: assertTrue(boolean2);
149: 
150: boolean boolean3 = AminoAcidSequence.isLegalCodon(':');
151: assertTrue(boolean3 == boolean1);
152: assertTrue(boolean3 == boolean0);
153: assertFalse(boolean3 == boolean2);
154: assertFalse(boolean3);
155: 
156: AminoAcidSequence aminoAcidSequence4 = AminoAcidSequence.getSpacedTranslation("", false);
157: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
158: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
159: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
160: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
161: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
162: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
163: assertEquals(25, AminoAcidSequence.symbol_count);
164: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
165: assertEquals(5, AminoAcidSequence.STOP_AA);
166: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence1));
167: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence2));
168: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence3));
169: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence0));
170: assertNotNull(aminoAcidSequence4);
171: assertEquals(0, aminoAcidSequence4.length());
172: assertFalse(aminoAcidSequence4.containsStopCodon());
173: assertEquals("", aminoAcidSequence4.toString());
174: assertNotSame(aminoAcidSequence4, aminoAcidSequence1);
175: assertNotSame(aminoAcidSequence4, aminoAcidSequence2);
176: assertNotSame(aminoAcidSequence4, aminoAcidSequence3);
177: assertNotSame(aminoAcidSequence4, aminoAcidSequence0);
178: 
179: char char2 = AminoAcidSequence.getSymbolFromIndex(0);
180: assertFalse(char2 == char1);
181: assertFalse(char2 == char0);
182: assertEquals('a', char2);

Test case 89

  1: char char0 = AminoAcidSequence.getOneLetterCode("dmE[d6+o,");
  2: assertEquals('\uFFFF', char0);
  3: 
  4: char char1 = AminoAcidSequence.getCodonTranslation('\uFFFF', '', '(');
  5: assertFalse(char1 == char0);
  6: assertEquals('.', char1);
  7: 
  8: boolean boolean0 = AminoAcidSequence.isStopCodon('');
  9: assertFalse(boolean0);
 10: 
 11: char[] charArray0 = new char[4];
 12: charArray0[0] = '\uFFFF';
 13: charArray0[1] = '\uFFFF';
 14: charArray0[2] = '(';
 15: charArray0[3] = '.';
 16: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, false);
 17: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 18: assertEquals(25, AminoAcidSequence.symbol_count);
 19: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 22: assertEquals(5, AminoAcidSequence.STOP_AA);
 23: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 24: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertArrayEquals(new char[] {'\uFFFF', '\uFFFF', '(', '.'}, charArray0);
 27: assertNotNull(aminoAcidSequence0);
 28: assertEquals(".  ", aminoAcidSequence0.toString());
 29: assertEquals(3, aminoAcidSequence0.length());
 30: assertFalse(aminoAcidSequence0.containsStopCodon());
 31: 
 32: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("dmE[d6+o,", false);
 33: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 34: assertEquals(5, AminoAcidSequence.STOP_AA);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(25, AminoAcidSequence.symbol_count);
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 39: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 40: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 41: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 42: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 43: assertNotNull(aminoAcidSequence1);
 44: assertEquals("...", aminoAcidSequence1.toString());
 45: assertEquals(3, aminoAcidSequence1.length());
 46: assertFalse(aminoAcidSequence1.containsStopCodon());
 47: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 48: 
 49: float float0 = aminoAcidSequence1.getMolecularWeight();
 50: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 51: assertEquals(5, AminoAcidSequence.STOP_AA);
 52: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 53: assertEquals(25, AminoAcidSequence.symbol_count);
 54: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 55: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 56: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 57: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 58: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 59: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 60: assertEquals((-36.03F), float0, 0.01F);
 61: assertEquals("...", aminoAcidSequence1.toString());
 62: assertEquals(3, aminoAcidSequence1.length());
 63: assertFalse(aminoAcidSequence1.containsStopCodon());
 64: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 65: 
 66: boolean boolean1 = aminoAcidSequence0.checkForMatch(aminoAcidSequence1);
 67: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 68: assertEquals(25, AminoAcidSequence.symbol_count);
 69: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 70: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 71: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 72: assertEquals(5, AminoAcidSequence.STOP_AA);
 73: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 74: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 75: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 76: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 77: assertEquals(5, AminoAcidSequence.STOP_AA);
 78: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 79: assertEquals(25, AminoAcidSequence.symbol_count);
 80: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 81: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 82: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 83: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 84: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 85: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 86: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 87: assertTrue(boolean1 == boolean0);
 88: assertFalse(boolean1);
 89: assertArrayEquals(new char[] {'\uFFFF', '\uFFFF', '(', '.'}, charArray0);
 90: assertEquals(".  ", aminoAcidSequence0.toString());
 91: assertEquals(3, aminoAcidSequence0.length());
 92: assertFalse(aminoAcidSequence0.containsStopCodon());
 93: assertEquals("...", aminoAcidSequence1.toString());
 94: assertEquals(3, aminoAcidSequence1.length());
 95: assertFalse(aminoAcidSequence1.containsStopCodon());
 96: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 97: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 98: 
 99: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation("Something is screwey - map is lying about key/values", false);
100: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
101: assertEquals(25, AminoAcidSequence.symbol_count);
102: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
103: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
104: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
105: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
106: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
107: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
108: assertEquals(5, AminoAcidSequence.STOP_AA);
109: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
110: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
111: assertNotNull(aminoAcidSequence2);
112: assertFalse(aminoAcidSequence2.containsStopCodon());
113: assertEquals(51, aminoAcidSequence2.length());
114: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  ", aminoAcidSequence2.toString());
115: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
116: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
117: 
118: AminoAcidSequence.getThreeLetterAbbreviation('\uFFFF');

Test case 90

  1: int int0 = AminoAcidSequence.getAminoAcidType('P');
  2: assertEquals(4, int0);
  3: 
  4: boolean boolean0 = AminoAcidSequence.isLegalCodon('%');
  5: assertFalse(boolean0);
  6: 
  7: BioJavaSequence bioJavaSequence0 = new BioJavaSequence((SymbolList) null);
  8: assertNotNull(bioJavaSequence0);
  9: 
 10: Bases bases0 = new Bases(bioJavaSequence0);
 11: assertEquals(5, Bases.MAX_PRIORITY);
 12: assertEquals(2, Bases.REVERSE);
 13: assertEquals((-5), Bases.MIN_PRIORITY);
 14: assertEquals(0, Bases.MEDIUM_PRIORITY);
 15: assertEquals(1, Bases.FORWARD);
 16: assertNotNull(bases0);
 17: 
 18: bioJavaSequence0.getGCount();

Test case 91

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("X4ue;7}1#=\"y l43v");
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  4: assertEquals(5, AminoAcidSequence.STOP_AA);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  7: assertEquals(25, AminoAcidSequence.symbol_count);
  8: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(17, aminoAcidSequence0.length());
 13: assertEquals("X4ue;7}1#=\"y l43v", aminoAcidSequence0.toString());
 14: assertTrue(aminoAcidSequence0.containsStopCodon());
 15: 
 16: AminoAcidSequence.getSymbolIndex('6');

Test case 92

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("X4ue;7}1#=\"y l43v");
  2: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  3: assertEquals(25, AminoAcidSequence.symbol_count);
  4: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  5: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals("X4ue;7}1#=\"y l43v", aminoAcidSequence0.toString());
 13: assertEquals(17, aminoAcidSequence0.length());
 14: assertTrue(aminoAcidSequence0.containsStopCodon());
 15: 
 16: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("X4ue;7}1#=\"y l43v", true);
 17: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 18: assertEquals(25, AminoAcidSequence.symbol_count);
 19: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 20: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 21: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 22: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 23: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 24: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 25: assertEquals(5, AminoAcidSequence.STOP_AA);
 26: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 27: assertNotNull(aminoAcidSequence1);
 28: assertFalse(aminoAcidSequence1.containsStopCodon());
 29: assertEquals(5, aminoAcidSequence1.length());
 30: assertEquals("xxxxx", aminoAcidSequence1.toString());
 31: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 32: 
 33: aminoAcidSequence0.getMolecularWeight();

Test case 93

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('y');
  2: assertTrue(boolean0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("");
  5: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  6: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  7: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  8: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 11: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 12: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals("", aminoAcidSequence0.toString());
 16: assertEquals(0, aminoAcidSequence0.length());
 17: assertFalse(aminoAcidSequence0.containsStopCodon());
 18: 
 19: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("", false);
 20: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 21: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 22: assertEquals(5, AminoAcidSequence.STOP_AA);
 23: assertEquals(25, AminoAcidSequence.symbol_count);
 24: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 25: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 26: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 27: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 28: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 29: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 30: assertNotNull(aminoAcidSequence1);
 31: assertFalse(aminoAcidSequence1.containsStopCodon());
 32: assertEquals("", aminoAcidSequence1.toString());
 33: assertEquals(0, aminoAcidSequence1.length());
 34: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 35: 
 36: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation("CeB^t'~e,HQZ", false);
 37: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 38: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 39: assertEquals(25, AminoAcidSequence.symbol_count);
 40: assertEquals(5, AminoAcidSequence.STOP_AA);
 41: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 42: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 43: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 44: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 45: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 46: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 47: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 48: assertNotNull(aminoAcidSequence2);
 49: assertEquals("....", aminoAcidSequence2.toString());
 50: assertFalse(aminoAcidSequence2.containsStopCodon());
 51: assertEquals(4, aminoAcidSequence2.length());
 52: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 53: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 54: 
 55: Bases bases0 = new Bases((Sequence) null);
 56: assertEquals(1, Bases.FORWARD);
 57: assertEquals(2, Bases.REVERSE);
 58: assertEquals((-5), Bases.MIN_PRIORITY);
 59: assertEquals(0, Bases.MEDIUM_PRIORITY);
 60: assertEquals(5, Bases.MAX_PRIORITY);
 61: assertNotNull(bases0);
 62: 
 63: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
 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: assertNotNull(simpleEntryGroup0);
 70: assertEquals(0, simpleEntryGroup0.refCount());
 71: assertEquals(0, simpleEntryGroup0.size());
 72: 
 73: FeatureVector featureVector0 = new FeatureVector();
 74: assertNotNull(featureVector0);
 75: 
 76: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureVector0, "");
 77: assertEquals(1, Bases.FORWARD);
 78: assertEquals(2, Bases.REVERSE);
 79: assertEquals((-5), Bases.MIN_PRIORITY);
 80: assertEquals(0, Bases.MEDIUM_PRIORITY);
 81: assertEquals(5, Bases.MAX_PRIORITY);
 82: assertNotNull(filteredEntryGroup0);
 83: assertEquals(0, simpleEntryGroup0.refCount());
 84: assertEquals(0, simpleEntryGroup0.size());
 85: assertEquals(0, filteredEntryGroup0.refCount());
 86: assertEquals(0, filteredEntryGroup0.size());
 87: assertEquals("", filteredEntryGroup0.getFilterName());
 88: 
 89: Clipboard clipboard0 = new Clipboard((String) null);
 90: assertNotNull(clipboard0);
 91: assertNull(clipboard0.getName());
 92: 
 93: Selection selection0 = new Selection(clipboard0);
 94: assertNotNull(selection0);
 95: assertNull(clipboard0.getName());
 96: 
 97: SimpleEntryGroup simpleEntryGroup1 = new SimpleEntryGroup();
 98: assertFalse(simpleEntryGroup1.equals((Object)simpleEntryGroup0));
 99: assertNotNull(simpleEntryGroup1);
100: assertEquals(0, simpleEntryGroup1.refCount());
101: assertEquals(0, simpleEntryGroup1.size());
102: 
103: SimpleGotoEventSource simpleGotoEventSource0 = new SimpleGotoEventSource(simpleEntryGroup1);
104: assertFalse(simpleEntryGroup1.equals((Object)simpleEntryGroup0));
105: assertNotNull(simpleGotoEventSource0);
106: assertEquals(0, simpleEntryGroup1.refCount());
107: assertEquals(0, simpleEntryGroup1.size());
108: 
109: JFormattedTextField jFormattedTextField0 = new JFormattedTextField();
110: assertNotNull(jFormattedTextField0);
111: assertTrue(jFormattedTextField0.getFocusTraversalKeysEnabled());
112: assertFalse(jFormattedTextField0.isFocusTraversalPolicySet());
113: assertFalse(jFormattedTextField0.getIgnoreRepaint());
114: assertFalse(jFormattedTextField0.isFocusCycleRoot());
115: assertFalse(jFormattedTextField0.isFocusTraversalPolicyProvider());
116: 
117: BasePlotGroup basePlotGroup0 = new BasePlotGroup(filteredEntryGroup0, jFormattedTextField0, selection0, simpleGotoEventSource0);

Test case 94

  1: int int0 = AminoAcidSequence.getAminoAcidType('3');
  2: assertEquals(7, int0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("", true);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 12: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals(0, aminoAcidSequence0.length());
 16: assertEquals("", aminoAcidSequence0.toString());
 17: assertFalse(aminoAcidSequence0.containsStopCodon());
 18: 
 19: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 22: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 23: assertEquals(5, AminoAcidSequence.STOP_AA);
 24: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 25: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 26: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 27: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 28: assertEquals(25, AminoAcidSequence.symbol_count);
 29: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 30: assertEquals(25, AminoAcidSequence.symbol_count);
 31: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 32: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 33: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 34: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 37: assertEquals(5, AminoAcidSequence.STOP_AA);
 38: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 39: assertNotNull(aminoAcidSequence1);
 40: assertEquals(0, aminoAcidSequence0.length());
 41: assertEquals("", aminoAcidSequence0.toString());
 42: assertFalse(aminoAcidSequence0.containsStopCodon());
 43: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
 44: assertFalse(aminoAcidSequence1.containsStopCodon());
 45: assertEquals(21, aminoAcidSequence1.length());
 46: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 47: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 48: 
 49: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation("", true);
 50: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 51: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 52: assertEquals(25, AminoAcidSequence.symbol_count);
 53: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 54: assertEquals(5, AminoAcidSequence.STOP_AA);
 55: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 56: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 57: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 58: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 59: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 60: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 61: assertNotNull(aminoAcidSequence2);
 62: assertFalse(aminoAcidSequence2.containsStopCodon());
 63: assertEquals(0, aminoAcidSequence2.length());
 64: assertEquals("", aminoAcidSequence2.toString());
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 66: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 67: 
 68: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("", false);
 69: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 70: assertEquals(5, AminoAcidSequence.STOP_AA);
 71: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 72: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 73: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 74: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 75: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 76: assertEquals(25, AminoAcidSequence.symbol_count);
 77: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 78: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 79: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 80: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 81: assertNotNull(aminoAcidSequence3);
 82: assertEquals("", aminoAcidSequence3.toString());
 83: assertEquals(0, aminoAcidSequence3.length());
 84: assertFalse(aminoAcidSequence3.containsStopCodon());
 85: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
 86: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
 87: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
 88: 
 89: AminoAcidSequence aminoAcidSequence4 = AminoAcidSequence.getSpacedTranslation("R3?e", false);
 90: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 91: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 92: assertEquals(25, AminoAcidSequence.symbol_count);
 93: assertEquals(5, AminoAcidSequence.STOP_AA);
 94: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 95: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 96: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 97: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 98: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 99: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence2));
100: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence1));
101: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence0));
102: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence3));
103: assertNotNull(aminoAcidSequence4);
104: assertFalse(aminoAcidSequence4.containsStopCodon());
105: assertEquals(3, aminoAcidSequence4.length());
106: assertEquals(".  ", aminoAcidSequence4.toString());
107: assertNotSame(aminoAcidSequence4, aminoAcidSequence2);
108: assertNotSame(aminoAcidSequence4, aminoAcidSequence1);
109: assertNotSame(aminoAcidSequence4, aminoAcidSequence0);
110: assertNotSame(aminoAcidSequence4, aminoAcidSequence3);
111: 
112: int int1 = AminoAcidSequence.getSymbolIndex('s');
113: assertFalse(int1 == int0);
114: assertEquals(15, int1);
115: 
116: AminoAcidSequence aminoAcidSequence5 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, false);
117: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
118: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
119: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
120: assertEquals(5, AminoAcidSequence.STOP_AA);
121: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
122: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
123: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
124: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
125: assertEquals(25, AminoAcidSequence.symbol_count);
126: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
127: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
128: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
129: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
130: assertEquals(5, AminoAcidSequence.STOP_AA);
131: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
132: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
133: assertEquals(25, AminoAcidSequence.symbol_count);
134: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
135: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
136: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
137: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
138: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
139: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence3));
140: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence1));
141: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence2));
142: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence0));
143: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence4));
144: assertNotNull(aminoAcidSequence5);
145: assertEquals(0, aminoAcidSequence0.length());
146: assertEquals("", aminoAcidSequence0.toString());
147: assertFalse(aminoAcidSequence0.containsStopCodon());
148: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence5.toString());
149: assertEquals(63, aminoAcidSequence5.length());
150: assertFalse(aminoAcidSequence5.containsStopCodon());
151: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
152: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
153: assertNotSame(aminoAcidSequence0, aminoAcidSequence5);
154: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
155: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
156: assertNotSame(aminoAcidSequence5, aminoAcidSequence3);
157: assertNotSame(aminoAcidSequence5, aminoAcidSequence1);
158: assertNotSame(aminoAcidSequence5, aminoAcidSequence2);
159: assertNotSame(aminoAcidSequence5, aminoAcidSequence0);
160: assertNotSame(aminoAcidSequence5, aminoAcidSequence4);
161: 
162: float float0 = aminoAcidSequence0.getMolecularWeight();
163: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
164: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
165: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
166: assertEquals(5, AminoAcidSequence.STOP_AA);
167: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
168: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
169: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
170: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
171: assertEquals(25, AminoAcidSequence.symbol_count);
172: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
173: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
174: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence5));
175: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
176: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
177: assertEquals(0.0F, float0, 0.01F);
178: assertEquals(0, aminoAcidSequence0.length());
179: assertEquals("", aminoAcidSequence0.toString());
180: assertFalse(aminoAcidSequence0.containsStopCodon());
181: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
182: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
183: assertNotSame(aminoAcidSequence0, aminoAcidSequence5);
184: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
185: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
186: 
187: AminoAcidSequence.setGeneCode();
188: AminoAcidSequence aminoAcidSequence6 = AminoAcidSequence.getTranslation("", true);
189: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
190: assertEquals(5, AminoAcidSequence.STOP_AA);
191: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
192: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
193: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
194: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
195: assertEquals(25, AminoAcidSequence.symbol_count);
196: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
197: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
198: assertFalse(aminoAcidSequence6.equals((Object)aminoAcidSequence4));
199: assertFalse(aminoAcidSequence6.equals((Object)aminoAcidSequence3));
200: assertFalse(aminoAcidSequence6.equals((Object)aminoAcidSequence1));
201: assertFalse(aminoAcidSequence6.equals((Object)aminoAcidSequence0));
202: assertFalse(aminoAcidSequence6.equals((Object)aminoAcidSequence2));
203: assertFalse(aminoAcidSequence6.equals((Object)aminoAcidSequence5));
204: assertNotNull(aminoAcidSequence6);
205: assertEquals("", aminoAcidSequence6.toString());
206: assertFalse(aminoAcidSequence6.containsStopCodon());
207: assertEquals(0, aminoAcidSequence6.length());
208: assertNotSame(aminoAcidSequence6, aminoAcidSequence4);
209: assertNotSame(aminoAcidSequence6, aminoAcidSequence3);
210: assertNotSame(aminoAcidSequence6, aminoAcidSequence1);
211: assertNotSame(aminoAcidSequence6, aminoAcidSequence0);
212: assertNotSame(aminoAcidSequence6, aminoAcidSequence2);
213: assertNotSame(aminoAcidSequence6, aminoAcidSequence5);
214: 
215: AminoAcidSequence aminoAcidSequence7 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence1.codon_translation_array, true);
216: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
217: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
218: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
219: assertEquals(5, AminoAcidSequence.STOP_AA);
220: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
221: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
222: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
223: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
224: assertEquals(25, AminoAcidSequence.symbol_count);
225: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
226: assertEquals(25, AminoAcidSequence.symbol_count);
227: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
228: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
229: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
230: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
231: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
232: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
233: assertEquals(5, AminoAcidSequence.STOP_AA);
234: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
235: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
236: assertEquals(25, AminoAcidSequence.symbol_count);
237: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
238: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
239: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
240: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
241: assertEquals(5, AminoAcidSequence.STOP_AA);
242: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
243: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
244: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
245: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence5));
246: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
247: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence6));
248: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
249: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence2));
250: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence4));
251: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence6));
252: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence5));
253: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence3));
254: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
255: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence4));
256: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence0));
257: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence5));
258: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence6));
259: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence3));
260: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence2));
261: assertFalse(aminoAcidSequence7.equals((Object)aminoAcidSequence1));
262: assertNotNull(aminoAcidSequence7);
263: assertEquals(0, aminoAcidSequence0.length());
264: assertEquals("", aminoAcidSequence0.toString());
265: assertFalse(aminoAcidSequence0.containsStopCodon());
266: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
267: assertFalse(aminoAcidSequence1.containsStopCodon());
268: assertEquals(21, aminoAcidSequence1.length());
269: assertEquals("x  x  x  x  x  x  x  x  x  x  x  x  f  x  x  x  x  x  x  x  g  ", aminoAcidSequence7.toString());
270: assertEquals(63, aminoAcidSequence7.length());
271: assertFalse(aminoAcidSequence7.containsStopCodon());
272: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
273: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
274: assertNotSame(aminoAcidSequence0, aminoAcidSequence7);
275: assertNotSame(aminoAcidSequence0, aminoAcidSequence5);
276: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
277: assertNotSame(aminoAcidSequence0, aminoAcidSequence6);
278: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
279: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
280: assertNotSame(aminoAcidSequence1, aminoAcidSequence4);
281: assertNotSame(aminoAcidSequence1, aminoAcidSequence6);
282: assertNotSame(aminoAcidSequence1, aminoAcidSequence5);
283: assertNotSame(aminoAcidSequence1, aminoAcidSequence3);
284: assertNotSame(aminoAcidSequence1, aminoAcidSequence7);
285: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
286: assertNotSame(aminoAcidSequence7, aminoAcidSequence4);
287: assertNotSame(aminoAcidSequence7, aminoAcidSequence0);
288: assertNotSame(aminoAcidSequence7, aminoAcidSequence5);
289: assertNotSame(aminoAcidSequence7, aminoAcidSequence6);
290: assertNotSame(aminoAcidSequence7, aminoAcidSequence3);
291: assertNotSame(aminoAcidSequence7, aminoAcidSequence2);
292: assertNotSame(aminoAcidSequence7, aminoAcidSequence1);
293: 
294: int int2 = aminoAcidSequence0.length();
295: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
296: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
297: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
298: assertEquals(5, AminoAcidSequence.STOP_AA);
299: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
300: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
301: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
302: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
303: assertEquals(25, AminoAcidSequence.symbol_count);
304: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
305: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
306: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence7));
307: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence5));
308: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
309: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence6));
310: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
311: assertFalse(int2 == int1);
312: assertFalse(int2 == int0);
313: assertEquals(0, int2);
314: assertEquals(0, aminoAcidSequence0.length());
315: assertEquals("", aminoAcidSequence0.toString());
316: assertFalse(aminoAcidSequence0.containsStopCodon());
317: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
318: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
319: assertNotSame(aminoAcidSequence0, aminoAcidSequence7);
320: assertNotSame(aminoAcidSequence0, aminoAcidSequence5);
321: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
322: assertNotSame(aminoAcidSequence0, aminoAcidSequence6);
323: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
324: 
325: String string0 = AminoAcidSequence.getThreeLetterAbbreviation('E');
326: assertEquals("Glu", string0);
327: assertNotNull(string0);
328: 
329: String string1 = AminoAcidSequence.getThreeLetterAbbreviation(5);
330: assertFalse(string1.equals((Object)string0));
331: assertEquals("Gln", string1);
332: assertNotNull(string1);
333: 
334: boolean boolean0 = aminoAcidSequence1.checkForMatch(aminoAcidSequence5);
335: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
336: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
337: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
338: assertEquals(5, AminoAcidSequence.STOP_AA);
339: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
340: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
341: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
342: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
343: assertEquals(25, AminoAcidSequence.symbol_count);
344: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
345: assertEquals(25, AminoAcidSequence.symbol_count);
346: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
347: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
348: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
349: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
350: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
351: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
352: assertEquals(5, AminoAcidSequence.STOP_AA);
353: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
354: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
355: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
356: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
357: assertEquals(5, AminoAcidSequence.STOP_AA);
358: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
359: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
360: assertEquals(25, AminoAcidSequence.symbol_count);
361: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
362: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
363: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
364: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence7));
365: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence5));
366: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
367: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence6));
368: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
369: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence2));
370: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence4));
371: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence6));
372: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence5));
373: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence3));
374: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence7));
375: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
376: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence3));
377: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence7));
378: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence1));
379: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence2));
380: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence0));
381: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence6));
382: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence4));
383: assertFalse(boolean0);
384: assertEquals(0, aminoAcidSequence0.length());
385: assertEquals("", aminoAcidSequence0.toString());
386: assertFalse(aminoAcidSequence0.containsStopCodon());
387: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence1.toString());
388: assertFalse(aminoAcidSequence1.containsStopCodon());
389: assertEquals(21, aminoAcidSequence1.length());
390: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence5.toString());
391: assertEquals(63, aminoAcidSequence5.length());
392: assertFalse(aminoAcidSequence5.containsStopCodon());
393: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
394: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
395: assertNotSame(aminoAcidSequence0, aminoAcidSequence7);
396: assertNotSame(aminoAcidSequence0, aminoAcidSequence5);
397: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
398: assertNotSame(aminoAcidSequence0, aminoAcidSequence6);
399: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
400: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
401: assertNotSame(aminoAcidSequence1, aminoAcidSequence4);
402: assertNotSame(aminoAcidSequence1, aminoAcidSequence6);
403: assertNotSame(aminoAcidSequence1, aminoAcidSequence5);
404: assertNotSame(aminoAcidSequence1, aminoAcidSequence3);
405: assertNotSame(aminoAcidSequence1, aminoAcidSequence7);
406: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
407: assertNotSame(aminoAcidSequence5, aminoAcidSequence3);
408: assertNotSame(aminoAcidSequence5, aminoAcidSequence7);
409: assertNotSame(aminoAcidSequence5, aminoAcidSequence1);
410: assertNotSame(aminoAcidSequence5, aminoAcidSequence2);
411: assertNotSame(aminoAcidSequence5, aminoAcidSequence0);
412: assertNotSame(aminoAcidSequence5, aminoAcidSequence6);
413: assertNotSame(aminoAcidSequence5, aminoAcidSequence4);
414: 
415: boolean boolean1 = aminoAcidSequence5.checkForMatch(aminoAcidSequence0);
416: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
417: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
418: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
419: assertEquals(5, AminoAcidSequence.STOP_AA);
420: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
421: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
422: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
423: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
424: assertEquals(25, AminoAcidSequence.symbol_count);
425: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
426: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
427: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
428: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
429: assertEquals(5, AminoAcidSequence.STOP_AA);
430: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
431: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
432: assertEquals(25, AminoAcidSequence.symbol_count);
433: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
434: assertTrue(boolean1 == boolean0);
435: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
436: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
437: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence7));
438: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence5));
439: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence4));
440: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence6));
441: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
442: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence3));
443: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence7));
444: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence1));
445: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence2));
446: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence0));
447: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence6));
448: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence4));
449: assertFalse(boolean1);
450: assertEquals(0, aminoAcidSequence0.length());
451: assertEquals("", aminoAcidSequence0.toString());
452: assertFalse(aminoAcidSequence0.containsStopCodon());
453: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence5.toString());
454: assertEquals(63, aminoAcidSequence5.length());
455: assertFalse(aminoAcidSequence5.containsStopCodon());
456: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
457: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
458: assertNotSame(aminoAcidSequence0, aminoAcidSequence7);
459: assertNotSame(aminoAcidSequence0, aminoAcidSequence5);
460: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
461: assertNotSame(aminoAcidSequence0, aminoAcidSequence6);
462: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
463: assertNotSame(aminoAcidSequence5, aminoAcidSequence3);
464: assertNotSame(aminoAcidSequence5, aminoAcidSequence7);
465: assertNotSame(aminoAcidSequence5, aminoAcidSequence1);
466: assertNotSame(aminoAcidSequence5, aminoAcidSequence2);
467: assertNotSame(aminoAcidSequence5, aminoAcidSequence0);
468: assertNotSame(aminoAcidSequence5, aminoAcidSequence6);
469: assertNotSame(aminoAcidSequence5, aminoAcidSequence4);
470: 
471: char char0 = AminoAcidSequence.getOneLetterCode("Gln");
472: assertEquals('q', char0);
473: 
474: aminoAcidSequence1.elementAt(91);

Test case 95

  1: AminoAcidSequence.setGeneCode();
  2: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(0);
  3: assertEquals("Ala", string0);
  4: assertNotNull(string0);
  5: 
  6: char[] charArray0 = new char[4];
  7: charArray0[0] = 'n';
  8: charArray0[1] = ',';
  9: charArray0[2] = '[';
 10: charArray0[3] = '{';
 11: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
 12: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 15: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 16: assertEquals(5, AminoAcidSequence.STOP_AA);
 17: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 18: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 19: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 20: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 21: assertArrayEquals(new char[] {'n', ',', '[', '{'}, charArray0);
 22: assertNotNull(aminoAcidSequence0);
 23: assertEquals(1, aminoAcidSequence0.length());
 24: assertFalse(aminoAcidSequence0.containsStopCodon());
 25: assertEquals("x", aminoAcidSequence0.toString());
 26: 
 27: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Ala", false);
 28: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 29: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 32: assertEquals(5, AminoAcidSequence.STOP_AA);
 33: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 34: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 35: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 36: assertEquals(25, AminoAcidSequence.symbol_count);
 37: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 38: assertNotNull(aminoAcidSequence1);
 39: assertEquals(3, aminoAcidSequence1.length());
 40: assertEquals(".  ", aminoAcidSequence1.toString());
 41: assertFalse(aminoAcidSequence1.containsStopCodon());
 42: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 43: 
 44: char char0 = AminoAcidSequence.getOneLetterCode("Ala");
 45: assertEquals('a', char0);
 46: 
 47: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(charArray0, false);
 48: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 49: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 50: assertEquals(5, AminoAcidSequence.STOP_AA);
 51: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 52: assertEquals(25, AminoAcidSequence.symbol_count);
 53: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 54: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 55: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 56: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 57: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 58: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 59: assertArrayEquals(new char[] {'n', ',', '[', '{'}, charArray0);
 60: assertNotNull(aminoAcidSequence2);
 61: assertEquals(3, aminoAcidSequence2.length());
 62: assertEquals(".  ", aminoAcidSequence2.toString());
 63: assertFalse(aminoAcidSequence2.containsStopCodon());
 64: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 66: 
 67: String string1 = aminoAcidSequence0.toString();
 68: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 69: assertEquals(25, AminoAcidSequence.symbol_count);
 70: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 71: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 72: assertEquals(5, AminoAcidSequence.STOP_AA);
 73: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 74: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 75: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 76: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 77: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
 78: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 79: assertFalse(string1.equals((Object)string0));
 80: assertEquals("x", string1);
 81: assertArrayEquals(new char[] {'n', ',', '[', '{'}, charArray0);
 82: assertNotNull(string1);
 83: assertEquals(1, aminoAcidSequence0.length());
 84: assertFalse(aminoAcidSequence0.containsStopCodon());
 85: assertEquals("x", aminoAcidSequence0.toString());
 86: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 87: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 88: 
 89: AminoAcidSequence.setGeneCode();
 90: Character character0 = new Character(',');
 91: assertFalse(character0.equals((Object)char0));
 92: assertEquals(',', (char)character0);
 93: assertNotNull(character0);
 94: 
 95: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("Ala", true);
 96: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 97: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 98: assertEquals(5, AminoAcidSequence.STOP_AA);
 99: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
100: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
101: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
102: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
103: assertEquals(25, AminoAcidSequence.symbol_count);
104: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
105: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
106: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
107: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
108: assertNotNull(aminoAcidSequence3);
109: assertEquals("x", aminoAcidSequence3.toString());
110: assertFalse(aminoAcidSequence3.containsStopCodon());
111: assertEquals(1, aminoAcidSequence3.length());
112: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
113: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
114: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
115: 
116: AminoAcidSequence.getSymbolIndex('1');

Test case 96

  1: int int0 = AminoAcidSequence.getAminoAcidType('f');
  2: assertEquals(7, int0);
  3: 
  4: char[] charArray0 = new char[6];
  5: charArray0[0] = 'f';
  6: charArray0[1] = 'f';
  7: charArray0[2] = 'f';
  8: charArray0[3] = 'f';
  9: charArray0[4] = 'f';
 10: charArray0[5] = 'f';
 11: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
 12: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 13: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 14: assertEquals(25, AminoAcidSequence.symbol_count);
 15: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 16: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 17: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 18: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 19: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 20: assertEquals(5, AminoAcidSequence.STOP_AA);
 21: assertArrayEquals(new char[] {'f', 'f', 'f', 'f', 'f', 'f'}, charArray0);
 22: assertNotNull(aminoAcidSequence0);
 23: assertFalse(aminoAcidSequence0.containsStopCodon());
 24: assertEquals(6, aminoAcidSequence0.length());
 25: assertEquals("x  x  ", aminoAcidSequence0.toString());
 26: 
 27: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("AwlC^j", true);
 28: assertEquals(25, AminoAcidSequence.symbol_count);
 29: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 30: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 31: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 32: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 33: assertEquals(5, AminoAcidSequence.STOP_AA);
 34: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 35: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 36: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 37: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 38: assertNotNull(aminoAcidSequence1);
 39: assertFalse(aminoAcidSequence1.containsStopCodon());
 40: assertEquals("xx", aminoAcidSequence1.toString());
 41: assertEquals(2, aminoAcidSequence1.length());
 42: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 43: 
 44: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation("AwlC^j", true);
 45: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 46: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 47: assertEquals(25, AminoAcidSequence.symbol_count);
 48: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 49: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 50: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 51: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 52: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 53: assertEquals(5, AminoAcidSequence.STOP_AA);
 54: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 55: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 56: assertNotNull(aminoAcidSequence2);
 57: assertFalse(aminoAcidSequence2.containsStopCodon());
 58: assertEquals(2, aminoAcidSequence2.length());
 59: assertEquals("xx", aminoAcidSequence2.toString());
 60: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 61: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 62: 
 63: char char0 = AminoAcidSequence.getOneLetterCode("AwlC^j");
 64: assertEquals('\uFFFF', char0);
 65: 
 66: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence1.codon_translation_array, false);
 67: assertEquals(25, AminoAcidSequence.symbol_count);
 68: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 69: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 70: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 71: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 72: assertEquals(5, AminoAcidSequence.STOP_AA);
 73: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 74: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 75: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 76: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 77: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 78: assertEquals(25, AminoAcidSequence.symbol_count);
 79: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 80: assertEquals(5, AminoAcidSequence.STOP_AA);
 81: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 82: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 83: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 84: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 85: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence2));
 86: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 87: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 88: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 89: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 90: assertNotNull(aminoAcidSequence3);
 91: assertFalse(aminoAcidSequence1.containsStopCodon());
 92: assertEquals("xx", aminoAcidSequence1.toString());
 93: assertEquals(2, aminoAcidSequence1.length());
 94: assertFalse(aminoAcidSequence3.containsStopCodon());
 95: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence3.toString());
 96: assertEquals(63, aminoAcidSequence3.length());
 97: assertNotSame(aminoAcidSequence1, aminoAcidSequence3);
 98: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 99: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
100: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
101: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
102: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
103: 
104: AminoAcidSequence aminoAcidSequence4 = AminoAcidSequence.getTranslation(aminoAcidSequence1.codon_translation_array, true);
105: assertEquals(25, AminoAcidSequence.symbol_count);
106: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
107: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
108: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
109: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
110: assertEquals(5, AminoAcidSequence.STOP_AA);
111: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
112: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
113: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
114: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
115: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
116: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
117: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
118: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
119: assertEquals(5, AminoAcidSequence.STOP_AA);
120: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
121: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
122: assertEquals(25, AminoAcidSequence.symbol_count);
123: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence3));
124: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
125: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence2));
126: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence1));
127: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence0));
128: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence2));
129: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence3));
130: assertNotNull(aminoAcidSequence4);
131: assertFalse(aminoAcidSequence1.containsStopCodon());
132: assertEquals("xx", aminoAcidSequence1.toString());
133: assertEquals(2, aminoAcidSequence1.length());
134: assertFalse(aminoAcidSequence4.containsStopCodon());
135: assertEquals(21, aminoAcidSequence4.length());
136: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence4.toString());
137: assertNotSame(aminoAcidSequence1, aminoAcidSequence4);
138: assertNotSame(aminoAcidSequence1, aminoAcidSequence3);
139: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
140: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
141: assertNotSame(aminoAcidSequence4, aminoAcidSequence1);
142: assertNotSame(aminoAcidSequence4, aminoAcidSequence0);
143: assertNotSame(aminoAcidSequence4, aminoAcidSequence2);
144: assertNotSame(aminoAcidSequence4, aminoAcidSequence3);
145: 
146: AminoAcidSequence aminoAcidSequence5 = AminoAcidSequence.getSpacedTranslation("AwlC^j", true);
147: assertEquals(25, AminoAcidSequence.symbol_count);
148: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
149: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
150: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
151: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
152: assertEquals(5, AminoAcidSequence.STOP_AA);
153: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
154: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
155: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
156: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence1));
157: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence4));
158: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence0));
159: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence2));
160: assertFalse(aminoAcidSequence5.equals((Object)aminoAcidSequence3));
161: assertNotNull(aminoAcidSequence5);
162: assertEquals("x  x  ", aminoAcidSequence5.toString());
163: assertEquals(6, aminoAcidSequence5.length());
164: assertFalse(aminoAcidSequence5.containsStopCodon());
165: assertNotSame(aminoAcidSequence5, aminoAcidSequence1);
166: assertNotSame(aminoAcidSequence5, aminoAcidSequence4);
167: assertNotSame(aminoAcidSequence5, aminoAcidSequence0);
168: assertNotSame(aminoAcidSequence5, aminoAcidSequence2);
169: assertNotSame(aminoAcidSequence5, aminoAcidSequence3);
170: 
171: int int1 = AminoAcidSequence.getSymbolIndex('f');
172: assertFalse(int1 == int0);
173: assertEquals(13, int1);
174: 
175: AminoAcidSequence.setGeneCode();
176: int int2 = AminoAcidSequence.getSymbolIndex('f');
177: assertFalse(int2 == int0);
178: assertTrue(int2 == int1);
179: assertEquals(13, int2);
180: 
181: aminoAcidSequence0.elementAt(17);

Test case 97

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("D7fg1y_a*phbinw ", false);
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  4: assertEquals(25, AminoAcidSequence.symbol_count);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  7: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertFalse(aminoAcidSequence0.containsStopCodon());
 13: assertEquals(".  .  .  .  .  ", aminoAcidSequence0.toString());
 14: assertEquals(15, aminoAcidSequence0.length());
 15: 
 16: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 17: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 18: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 19: assertEquals(25, AminoAcidSequence.symbol_count);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 22: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 23: assertEquals(5, AminoAcidSequence.STOP_AA);
 24: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 25: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 26: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 27: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 28: assertEquals(5, AminoAcidSequence.STOP_AA);
 29: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 30: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 31: assertEquals(25, AminoAcidSequence.symbol_count);
 32: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 33: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 34: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 35: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 36: assertNotNull(aminoAcidSequence1);
 37: assertFalse(aminoAcidSequence0.containsStopCodon());
 38: assertEquals(".  .  .  .  .  ", aminoAcidSequence0.toString());
 39: assertEquals(15, aminoAcidSequence0.length());
 40: assertEquals(21, aminoAcidSequence1.length());
 41: assertEquals("............f.......g", aminoAcidSequence1.toString());
 42: assertFalse(aminoAcidSequence1.containsStopCodon());
 43: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 44: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 45: 
 46: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 47: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 48: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 49: assertEquals(25, AminoAcidSequence.symbol_count);
 50: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 51: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 52: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 53: assertEquals(5, AminoAcidSequence.STOP_AA);
 54: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 55: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 56: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 57: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 58: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 59: assertEquals(25, AminoAcidSequence.symbol_count);
 60: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 61: assertEquals(5, AminoAcidSequence.STOP_AA);
 62: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 63: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 64: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 65: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 66: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 67: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 68: assertNotNull(aminoAcidSequence2);
 69: assertFalse(aminoAcidSequence0.containsStopCodon());
 70: assertEquals(".  .  .  .  .  ", aminoAcidSequence0.toString());
 71: assertEquals(15, aminoAcidSequence0.length());
 72: assertEquals(21, aminoAcidSequence2.length());
 73: assertFalse(aminoAcidSequence2.containsStopCodon());
 74: assertEquals("............f.......g", aminoAcidSequence2.toString());
 75: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 76: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 77: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 78: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 79: 
 80: char char0 = AminoAcidSequence.getOneLetterCode("Alphabet of all doubles.");
 81: assertEquals('\uFFFF', char0);
 82: 
 83: AminoAcidSequence.setGeneCode();
 84: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence0.codon_translation_array, false);
 85: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 86: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 87: assertEquals(25, AminoAcidSequence.symbol_count);
 88: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 89: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 90: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 91: assertEquals(5, AminoAcidSequence.STOP_AA);
 92: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 93: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 94: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 95: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 96: assertEquals(5, AminoAcidSequence.STOP_AA);
 97: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 98: assertEquals(25, AminoAcidSequence.symbol_count);
 99: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
100: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
101: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
102: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
103: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
104: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
105: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
106: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
107: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
108: assertNotNull(aminoAcidSequence3);
109: assertFalse(aminoAcidSequence0.containsStopCodon());
110: assertEquals(".  .  .  .  .  ", aminoAcidSequence0.toString());
111: assertEquals(15, aminoAcidSequence0.length());
112: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence3.toString());
113: assertEquals(63, aminoAcidSequence3.length());
114: assertFalse(aminoAcidSequence3.containsStopCodon());
115: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
116: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
117: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
118: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
119: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
120: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
121: 
122: AminoAcidSequence aminoAcidSequence4 = AminoAcidSequence.getTranslation(aminoAcidSequence3.codon_translation_array, false);
123: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
124: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
125: assertEquals(25, AminoAcidSequence.symbol_count);
126: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
127: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
128: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
129: assertEquals(5, AminoAcidSequence.STOP_AA);
130: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
131: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
132: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
133: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
134: assertEquals(5, AminoAcidSequence.STOP_AA);
135: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
136: assertEquals(25, AminoAcidSequence.symbol_count);
137: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
138: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
139: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
140: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
141: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
142: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
143: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
144: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
145: assertEquals(5, AminoAcidSequence.STOP_AA);
146: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
147: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
148: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
149: assertEquals(25, AminoAcidSequence.symbol_count);
150: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
151: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
152: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
153: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
154: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
155: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
156: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence3));
157: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence0));
158: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence1));
159: assertFalse(aminoAcidSequence4.equals((Object)aminoAcidSequence2));
160: assertNotNull(aminoAcidSequence4);
161: assertFalse(aminoAcidSequence0.containsStopCodon());
162: assertEquals(".  .  .  .  .  ", aminoAcidSequence0.toString());
163: assertEquals(15, aminoAcidSequence0.length());
164: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence3.toString());
165: assertEquals(63, aminoAcidSequence3.length());
166: assertFalse(aminoAcidSequence3.containsStopCodon());
167: assertEquals("............f.......g", aminoAcidSequence4.toString());
168: assertFalse(aminoAcidSequence4.containsStopCodon());
169: assertEquals(21, aminoAcidSequence4.length());
170: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
171: assertNotSame(aminoAcidSequence0, aminoAcidSequence4);
172: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
173: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
174: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
175: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
176: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
177: assertNotSame(aminoAcidSequence3, aminoAcidSequence4);
178: assertNotSame(aminoAcidSequence4, aminoAcidSequence3);
179: assertNotSame(aminoAcidSequence4, aminoAcidSequence0);
180: assertNotSame(aminoAcidSequence4, aminoAcidSequence1);
181: assertNotSame(aminoAcidSequence4, aminoAcidSequence2);
182: 
183: char char1 = AminoAcidSequence.getOneLetterCode("Alphabet of all doubles.");
184: assertTrue(char1 == char0);
185: assertEquals('\uFFFF', char1);
186: 
187: int int0 = AminoAcidSequence.getAminoAcidType('#');
188: assertEquals(5, int0);
189: 
190: AminoAcidSequence.getThreeLetterAbbreviation(64);

Test case 98

  1: AminoAcidSequence.getSymbolIndex('2');

Test case 99

  1: int int0 = AminoAcidSequence.getAminoAcidType('$');
  2: assertEquals(7, int0);
  3: 
  4: char[] charArray0 = new char[2];
  5: charArray0[0] = '$';
  6: charArray0[1] = '$';
  7: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, false);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 11: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 12: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 15: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 16: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 17: assertArrayEquals(new char[] {'$', '$'}, charArray0);
 18: assertNotNull(aminoAcidSequence0);
 19: assertEquals("", aminoAcidSequence0.toString());
 20: assertEquals(0, aminoAcidSequence0.length());
 21: assertFalse(aminoAcidSequence0.containsStopCodon());
 22: 
 23: AminoAcidSequence.setGeneCode();
 24: float float0 = aminoAcidSequence0.getMolecularWeight();
 25: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 26: assertEquals(5, AminoAcidSequence.STOP_AA);
 27: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 28: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 29: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 30: assertEquals(25, AminoAcidSequence.symbol_count);
 31: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 32: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 33: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 34: assertEquals(0.0F, float0, 0.01F);
 35: assertArrayEquals(new char[] {'$', '$'}, charArray0);
 36: assertEquals("", aminoAcidSequence0.toString());
 37: assertEquals(0, aminoAcidSequence0.length());
 38: assertFalse(aminoAcidSequence0.containsStopCodon());
 39: 
 40: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
 41: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 42: assertEquals(25, AminoAcidSequence.symbol_count);
 43: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 44: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 45: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 46: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 47: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 48: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 49: assertEquals(5, AminoAcidSequence.STOP_AA);
 50: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 51: assertArrayEquals(new char[] {'$', '$'}, charArray0);
 52: assertNotNull(aminoAcidSequence1);
 53: assertEquals(0, aminoAcidSequence1.length());
 54: assertEquals("", aminoAcidSequence1.toString());
 55: assertFalse(aminoAcidSequence1.containsStopCodon());
 56: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 57: 
 58: AminoAcidSequence.getOneLetterCode((String) null);

Test case 100

  1: AminoAcidSequence.getSymbolIndex('(');

Test case 101

  1: char[] charArray0 = new char[2];
  2: charArray0[0] = 'X';
  3: charArray0[1] = 'y';
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, true);
  5: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(5, AminoAcidSequence.STOP_AA);
  8: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  9: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 10: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 11: assertEquals(25, AminoAcidSequence.symbol_count);
 12: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 13: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 14: assertArrayEquals(new char[] {'X', 'y'}, charArray0);
 15: assertNotNull(aminoAcidSequence0);
 16: assertEquals(0, aminoAcidSequence0.length());
 17: assertFalse(aminoAcidSequence0.containsStopCodon());
 18: assertEquals("", aminoAcidSequence0.toString());
 19: 
 20: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Sel", false);
 21: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 22: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 23: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 24: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 25: assertEquals(25, AminoAcidSequence.symbol_count);
 26: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 27: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 28: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 29: assertEquals(5, AminoAcidSequence.STOP_AA);
 30: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 31: assertNotNull(aminoAcidSequence1);
 32: assertEquals(3, aminoAcidSequence1.length());
 33: assertFalse(aminoAcidSequence1.containsStopCodon());
 34: assertEquals(".  ", aminoAcidSequence1.toString());
 35: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 36: 
 37: AminoAcidSequence.setGeneCode();
 38: int int0 = AminoAcidSequence.getSymbolIndex('X');
 39: assertEquals(23, int0);
 40: 
 41: int int1 = AminoAcidSequence.getSymbolIndex('y');
 42: assertFalse(int1 == int0);
 43: assertEquals(18, int1);
 44: 
 45: char char0 = AminoAcidSequence.getOneLetterCode("Sel");
 46: assertEquals('u', char0);
 47: 
 48: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence1.codon_translation_array, false);
 49: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 50: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 51: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 52: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 53: assertEquals(25, AminoAcidSequence.symbol_count);
 54: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 55: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 56: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 57: assertEquals(5, AminoAcidSequence.STOP_AA);
 58: assertEquals(25, AminoAcidSequence.symbol_count);
 59: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 60: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 61: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 62: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 63: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 64: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 65: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 66: assertEquals(5, AminoAcidSequence.STOP_AA);
 67: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 68: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 69: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 70: assertNotNull(aminoAcidSequence2);
 71: assertEquals(3, aminoAcidSequence1.length());
 72: assertFalse(aminoAcidSequence1.containsStopCodon());
 73: assertEquals(".  ", aminoAcidSequence1.toString());
 74: assertEquals("............f.......g", aminoAcidSequence2.toString());
 75: assertFalse(aminoAcidSequence2.containsStopCodon());
 76: assertEquals(21, aminoAcidSequence2.length());
 77: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 78: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
 79: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 80: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 81: 
 82: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("ai*L@y:[|2&[K", true);
 83: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 84: assertEquals(5, AminoAcidSequence.STOP_AA);
 85: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 86: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 87: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 88: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 89: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 90: assertEquals(25, AminoAcidSequence.symbol_count);
 91: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 92: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 93: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 94: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 95: assertNotNull(aminoAcidSequence3);
 96: assertEquals("xxxx", aminoAcidSequence3.toString());
 97: assertEquals(4, aminoAcidSequence3.length());
 98: assertFalse(aminoAcidSequence3.containsStopCodon());
 99: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
100: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
101: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
102: 
103: boolean boolean0 = aminoAcidSequence3.checkForMatch(aminoAcidSequence0);
104: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
105: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
106: assertEquals(5, AminoAcidSequence.STOP_AA);
107: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
108: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
109: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
110: assertEquals(25, AminoAcidSequence.symbol_count);
111: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
112: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
113: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
114: assertEquals(5, AminoAcidSequence.STOP_AA);
115: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
116: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
117: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
118: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
119: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
120: assertEquals(25, AminoAcidSequence.symbol_count);
121: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
122: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
123: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
124: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
125: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
126: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
127: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
128: assertFalse(boolean0);
129: assertArrayEquals(new char[] {'X', 'y'}, charArray0);
130: assertEquals(0, aminoAcidSequence0.length());
131: assertFalse(aminoAcidSequence0.containsStopCodon());
132: assertEquals("", aminoAcidSequence0.toString());
133: assertEquals("xxxx", aminoAcidSequence3.toString());
134: assertEquals(4, aminoAcidSequence3.length());
135: assertFalse(aminoAcidSequence3.containsStopCodon());
136: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
137: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
138: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
139: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
140: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
141: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
142: 
143: char char1 = AminoAcidSequence.getOneLetterCode("Sel");
144: assertTrue(char1 == char0);
145: assertEquals('u', char1);

Test case 102

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('5');
  2: assertFalse(boolean0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Not(", false);
  5: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  6: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  7: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 10: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 11: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 12: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertNotNull(aminoAcidSequence0);
 15: assertEquals(1, aminoAcidSequence0.length());
 16: assertEquals(".", aminoAcidSequence0.toString());
 17: assertFalse(aminoAcidSequence0.containsStopCodon());
 18: 
 19: float float0 = aminoAcidSequence0.getMolecularWeight();
 20: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 21: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 22: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 23: assertEquals(5, AminoAcidSequence.STOP_AA);
 24: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 25: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 26: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 27: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 28: assertEquals(25, AminoAcidSequence.symbol_count);
 29: assertEquals(0.0F, float0, 0.01F);
 30: assertEquals(1, aminoAcidSequence0.length());
 31: assertEquals(".", aminoAcidSequence0.toString());
 32: assertFalse(aminoAcidSequence0.containsStopCodon());
 33: 
 34: String string0 = aminoAcidSequence0.toString();
 35: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 36: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 37: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 38: assertEquals(5, AminoAcidSequence.STOP_AA);
 39: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 40: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 41: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 42: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 43: assertEquals(25, AminoAcidSequence.symbol_count);
 44: assertEquals(".", string0);
 45: assertNotNull(string0);
 46: assertEquals(1, aminoAcidSequence0.length());
 47: assertEquals(".", aminoAcidSequence0.toString());
 48: assertFalse(aminoAcidSequence0.containsStopCodon());
 49: 
 50: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 51: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 52: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 53: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 54: assertEquals(5, AminoAcidSequence.STOP_AA);
 55: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 56: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 57: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 58: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 59: assertEquals(25, AminoAcidSequence.symbol_count);
 60: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 61: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 62: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 63: assertEquals(5, AminoAcidSequence.STOP_AA);
 64: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 65: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 66: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 67: assertEquals(25, AminoAcidSequence.symbol_count);
 68: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 69: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 70: assertNotNull(aminoAcidSequence1);
 71: assertEquals(1, aminoAcidSequence0.length());
 72: assertEquals(".", aminoAcidSequence0.toString());
 73: assertFalse(aminoAcidSequence0.containsStopCodon());
 74: assertEquals("............f.......g", aminoAcidSequence1.toString());
 75: assertFalse(aminoAcidSequence1.containsStopCodon());
 76: assertEquals(21, aminoAcidSequence1.length());
 77: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 78: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 79: 
 80: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence1.codon_translation_array, false);
 81: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 82: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 83: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 84: assertEquals(5, AminoAcidSequence.STOP_AA);
 85: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 86: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 87: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 88: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 89: assertEquals(25, AminoAcidSequence.symbol_count);
 90: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 91: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 92: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 93: assertEquals(5, AminoAcidSequence.STOP_AA);
 94: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 95: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 96: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 97: assertEquals(25, AminoAcidSequence.symbol_count);
 98: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 99: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
100: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
101: assertEquals(5, AminoAcidSequence.STOP_AA);
102: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
103: assertEquals(25, AminoAcidSequence.symbol_count);
104: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
105: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
106: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
107: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
108: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
109: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
110: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
111: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
112: assertNotNull(aminoAcidSequence2);
113: assertEquals(1, aminoAcidSequence0.length());
114: assertEquals(".", aminoAcidSequence0.toString());
115: assertFalse(aminoAcidSequence0.containsStopCodon());
116: assertEquals("............f.......g", aminoAcidSequence1.toString());
117: assertFalse(aminoAcidSequence1.containsStopCodon());
118: assertEquals(21, aminoAcidSequence1.length());
119: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence2.toString());
120: assertEquals(63, aminoAcidSequence2.length());
121: assertFalse(aminoAcidSequence2.containsStopCodon());
122: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
123: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
124: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
125: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
126: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
127: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
128: 
129: char char0 = AminoAcidSequence.getOneLetterCode(".");
130: assertEquals('\uFFFF', char0);
131: 
132: char char1 = File.pathSeparatorChar;
133: assertFalse(char1 == char0);
134: assertEquals(':', char1);
135: 
136: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("Not(", true);
137: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
138: assertEquals(25, AminoAcidSequence.symbol_count);
139: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
140: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
141: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
142: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
143: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
144: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
145: assertEquals(5, AminoAcidSequence.STOP_AA);
146: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
147: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
148: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
149: assertNotNull(aminoAcidSequence3);
150: assertEquals(1, aminoAcidSequence3.length());
151: assertFalse(aminoAcidSequence3.containsStopCodon());
152: assertEquals("x", aminoAcidSequence3.toString());
153: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
154: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
155: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
156: 
157: String string1 = aminoAcidSequence0.toString();
158: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
159: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
160: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
161: assertEquals(5, AminoAcidSequence.STOP_AA);
162: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
163: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
164: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
165: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
166: assertEquals(25, AminoAcidSequence.symbol_count);
167: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
168: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence3));
169: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
170: assertEquals(".", string1);
171: assertNotNull(string1);
172: assertEquals(1, aminoAcidSequence0.length());
173: assertEquals(".", aminoAcidSequence0.toString());
174: assertFalse(aminoAcidSequence0.containsStopCodon());
175: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
176: assertNotSame(aminoAcidSequence0, aminoAcidSequence3);
177: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
178: 
179: aminoAcidSequence0.elementAt((-1692));

Test case 103

  1: char[] charArray0 = new char[0];
  2: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation(charArray0, false);
  3: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  4: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  5: assertEquals(5, AminoAcidSequence.STOP_AA);
  6: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(25, AminoAcidSequence.symbol_count);
  9: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 10: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 11: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 12: assertArrayEquals(new char[] {}, charArray0);
 13: assertNotNull(aminoAcidSequence0);
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: assertEquals(0, aminoAcidSequence0.length());
 16: assertEquals("", aminoAcidSequence0.toString());
 17: 
 18: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("Lys", true);
 19: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 20: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 21: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 22: assertEquals(25, AminoAcidSequence.symbol_count);
 23: assertEquals(5, AminoAcidSequence.STOP_AA);
 24: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 25: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 26: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 27: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 28: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 29: assertNotNull(aminoAcidSequence1);
 30: assertEquals(1, aminoAcidSequence1.length());
 31: assertEquals("x", aminoAcidSequence1.toString());
 32: assertFalse(aminoAcidSequence1.containsStopCodon());
 33: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 34: 
 35: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, true);
 36: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 37: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 38: assertEquals(5, AminoAcidSequence.STOP_AA);
 39: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 40: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 41: assertEquals(25, AminoAcidSequence.symbol_count);
 42: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 43: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 44: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 45: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 46: assertEquals(5, AminoAcidSequence.STOP_AA);
 47: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 48: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 49: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 50: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 51: assertEquals(25, AminoAcidSequence.symbol_count);
 52: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 53: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 54: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
 55: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 56: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 57: assertArrayEquals(new char[] {}, charArray0);
 58: assertNotNull(aminoAcidSequence2);
 59: assertFalse(aminoAcidSequence0.containsStopCodon());
 60: assertEquals(0, aminoAcidSequence0.length());
 61: assertEquals("", aminoAcidSequence0.toString());
 62: assertEquals(21, aminoAcidSequence2.length());
 63: assertEquals("xxxxxxxxxxxxfxxxxxxxg", aminoAcidSequence2.toString());
 64: assertFalse(aminoAcidSequence2.containsStopCodon());
 65: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 66: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
 67: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 68: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 69: 
 70: AminoAcidSequence.setGeneCode();
 71: int int0 = AminoAcidSequence.getSymbolIndex('V');
 72: assertEquals(19, int0);
 73: 
 74: boolean boolean0 = AminoAcidSequence.isLegalCodon(',');
 75: assertFalse(boolean0);
 76: 
 77: char char0 = AminoAcidSequence.getOneLetterCode("Ser");
 78: assertEquals('s', char0);

Test case 104

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('8');
  2: assertFalse(boolean0);
  3: 
  4: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getTranslation("Not(", false);
  5: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  8: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 11: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 12: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 13: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 14: assertNotNull(aminoAcidSequence0);
 15: assertFalse(aminoAcidSequence0.containsStopCodon());
 16: assertEquals(".", aminoAcidSequence0.toString());
 17: assertEquals(1, aminoAcidSequence0.length());
 18: 
 19: float float0 = aminoAcidSequence0.getMolecularWeight();
 20: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 21: assertEquals(25, AminoAcidSequence.symbol_count);
 22: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 23: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 24: assertEquals(5, AminoAcidSequence.STOP_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 27: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 28: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 29: assertEquals(0.0F, float0, 0.01F);
 30: assertFalse(aminoAcidSequence0.containsStopCodon());
 31: assertEquals(".", aminoAcidSequence0.toString());
 32: assertEquals(1, aminoAcidSequence0.length());
 33: 
 34: String string0 = aminoAcidSequence0.toString();
 35: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 36: assertEquals(25, AminoAcidSequence.symbol_count);
 37: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 38: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 39: assertEquals(5, AminoAcidSequence.STOP_AA);
 40: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 41: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 42: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 43: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 44: assertEquals(".", string0);
 45: assertNotNull(string0);
 46: assertFalse(aminoAcidSequence0.containsStopCodon());
 47: assertEquals(".", aminoAcidSequence0.toString());
 48: assertEquals(1, aminoAcidSequence0.length());
 49: 
 50: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation(aminoAcidSequence0.codon_translation_array, false);
 51: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 52: assertEquals(25, AminoAcidSequence.symbol_count);
 53: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 54: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 55: assertEquals(5, AminoAcidSequence.STOP_AA);
 56: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 57: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 58: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 59: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 60: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 61: assertEquals(5, AminoAcidSequence.STOP_AA);
 62: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 63: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 64: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 65: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 66: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 67: assertEquals(25, AminoAcidSequence.symbol_count);
 68: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 69: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 70: assertNotNull(aminoAcidSequence1);
 71: assertFalse(aminoAcidSequence0.containsStopCodon());
 72: assertEquals(".", aminoAcidSequence0.toString());
 73: assertEquals(1, aminoAcidSequence0.length());
 74: assertEquals("............f.......g", aminoAcidSequence1.toString());
 75: assertFalse(aminoAcidSequence1.containsStopCodon());
 76: assertEquals(21, aminoAcidSequence1.length());
 77: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
 78: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 79: 
 80: AminoAcidSequence.setGeneCode();
 81: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(aminoAcidSequence1.codon_translation_array, false);
 82: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 83: assertEquals(25, AminoAcidSequence.symbol_count);
 84: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 85: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 86: assertEquals(5, AminoAcidSequence.STOP_AA);
 87: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 88: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 89: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 90: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 91: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 92: assertEquals(5, AminoAcidSequence.STOP_AA);
 93: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 94: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 95: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 96: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 97: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 98: assertEquals(25, AminoAcidSequence.symbol_count);
 99: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
100: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
101: assertEquals(5, AminoAcidSequence.STOP_AA);
102: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
103: assertEquals(25, AminoAcidSequence.symbol_count);
104: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
105: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
106: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
107: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
108: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
109: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
110: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
111: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
112: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
113: assertNotNull(aminoAcidSequence2);
114: assertFalse(aminoAcidSequence0.containsStopCodon());
115: assertEquals(".", aminoAcidSequence0.toString());
116: assertEquals(1, aminoAcidSequence0.length());
117: assertEquals("............f.......g", aminoAcidSequence1.toString());
118: assertFalse(aminoAcidSequence1.containsStopCodon());
119: assertEquals(21, aminoAcidSequence1.length());
120: assertEquals(".  .  .  .  .  .  .  .  .  .  .  .  f  .  .  .  .  .  .  .  g  ", aminoAcidSequence2.toString());
121: assertFalse(aminoAcidSequence2.containsStopCodon());
122: assertEquals(63, aminoAcidSequence2.length());
123: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
124: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
125: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
126: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
127: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
128: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
129: 
130: char char0 = AminoAcidSequence.getCodonTranslation("Not(");
131: assertEquals('.', char0);
132: 
133: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getTranslation("Not(", true);
134: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
135: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
136: assertEquals(5, AminoAcidSequence.STOP_AA);
137: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
138: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
139: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
140: assertEquals(25, AminoAcidSequence.symbol_count);
141: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
142: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
143: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
144: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
145: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
146: assertNotNull(aminoAcidSequence3);
147: assertEquals("x", aminoAcidSequence3.toString());
148: assertFalse(aminoAcidSequence3.containsStopCodon());
149: assertEquals(1, aminoAcidSequence3.length());
150: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
151: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
152: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
153: 
154: AminoAcidSequence.getSymbolIndex('8');

Test case 105

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(0);
  2: assertEquals("Ala", string0);
  3: assertNotNull(string0);
  4: 
  5: String string1 = AminoAcidSequence.getThreeLetterAbbreviation('t');
  6: assertFalse(string1.equals((Object)string0));
  7: assertEquals("Thr", string1);
  8: assertNotNull(string1);
  9: 
 10: char char0 = AminoAcidSequence.getCodonTranslation('t', 't', ';');
 11: assertEquals('.', char0);
 12: 
 13: int int0 = AminoAcidSequence.getAminoAcidType('7');
 14: assertEquals(7, int0);
 15: 
 16: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("x)]ru^jkDJ*", true);
 17: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 18: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 19: assertEquals(25, AminoAcidSequence.symbol_count);
 20: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 21: assertEquals(5, AminoAcidSequence.STOP_AA);
 22: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 23: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 24: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertNotNull(aminoAcidSequence0);
 27: assertEquals(12, aminoAcidSequence0.length());
 28: assertEquals("x  x  x  x  ", aminoAcidSequence0.toString());
 29: assertFalse(aminoAcidSequence0.containsStopCodon());
 30: 
 31: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getTranslation("ISn", false);
 32: assertEquals(25, AminoAcidSequence.symbol_count);
 33: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 34: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 37: assertEquals(5, AminoAcidSequence.STOP_AA);
 38: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 39: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 40: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 41: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 42: assertNotNull(aminoAcidSequence1);
 43: assertEquals(".", aminoAcidSequence1.toString());
 44: assertFalse(aminoAcidSequence1.containsStopCodon());
 45: assertEquals(1, aminoAcidSequence1.length());
 46: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 47: 
 48: char char1 = AminoAcidSequence.getOneLetterCode("x)]ru^jkDJ*");
 49: assertFalse(char1 == char0);
 50: assertEquals('\uFFFF', char1);
 51: 
 52: AminoAcidSequence aminoAcidSequence2 = new AminoAcidSequence("Ala");
 53: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 54: assertEquals(5, AminoAcidSequence.STOP_AA);
 55: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 56: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 57: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 58: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 59: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 60: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 61: assertEquals(25, AminoAcidSequence.symbol_count);
 62: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 63: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 64: assertNotNull(aminoAcidSequence2);
 65: assertFalse(aminoAcidSequence2.containsStopCodon());
 66: assertEquals(3, aminoAcidSequence2.length());
 67: assertEquals("Ala", aminoAcidSequence2.toString());
 68: 
 69: AminoAcidSequence aminoAcidSequence3 = AminoAcidSequence.getSpacedTranslation("Ala", true);
 70: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 71: assertEquals(5, AminoAcidSequence.STOP_AA);
 72: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 73: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 74: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 75: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 76: assertEquals(25, AminoAcidSequence.symbol_count);
 77: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 78: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 79: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence0));
 80: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence2));
 81: assertFalse(aminoAcidSequence3.equals((Object)aminoAcidSequence1));
 82: assertNotNull(aminoAcidSequence3);
 83: assertEquals(3, aminoAcidSequence3.length());
 84: assertFalse(aminoAcidSequence3.containsStopCodon());
 85: assertEquals("x  ", aminoAcidSequence3.toString());
 86: assertNotSame(aminoAcidSequence3, aminoAcidSequence0);
 87: assertNotSame(aminoAcidSequence3, aminoAcidSequence2);
 88: assertNotSame(aminoAcidSequence3, aminoAcidSequence1);
 89: 
 90: AminoAcidSequence.setGeneCode();
 91: int int1 = AminoAcidSequence.getSymbolIndex('C');
 92: assertFalse(int1 == int0);
 93: assertEquals(4, int1);
 94: 
 95: int int2 = aminoAcidSequence1.length();
 96: assertEquals(25, AminoAcidSequence.symbol_count);
 97: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 98: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 99: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
100: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
101: assertEquals(5, AminoAcidSequence.STOP_AA);
102: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
103: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
104: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
105: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
106: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence2));
107: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence3));
108: assertFalse(int2 == int1);
109: assertFalse(int2 == int0);
110: assertEquals(1, int2);
111: assertEquals(".", aminoAcidSequence1.toString());
112: assertFalse(aminoAcidSequence1.containsStopCodon());
113: assertEquals(1, aminoAcidSequence1.length());
114: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
115: assertNotSame(aminoAcidSequence1, aminoAcidSequence2);
116: assertNotSame(aminoAcidSequence1, aminoAcidSequence3);
117: 
118: AminoAcidSequence.setGeneCode();
119: aminoAcidSequence2.elementAt(510);

Test case 106

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(0);
  2: assertEquals("Ala", string0);
  3: assertNotNull(string0);
  4: 
  5: int int0 = AminoAcidSequence.getAminoAcidType('8');
  6: assertEquals(7, int0);
  7: 
  8: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("x)]ru^jkDJ*", false);
  9: assertEquals(5, AminoAcidSequence.STOP_AA);
 10: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 11: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 12: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 13: assertEquals(25, AminoAcidSequence.symbol_count);
 14: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 15: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 16: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 17: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 18: assertNotNull(aminoAcidSequence0);
 19: assertEquals(12, aminoAcidSequence0.length());
 20: assertEquals(".  .  .  .  ", aminoAcidSequence0.toString());
 21: assertFalse(aminoAcidSequence0.containsStopCodon());
 22: 
 23: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Ala", true);
 24: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 25: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 26: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 27: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 28: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 29: assertEquals(5, AminoAcidSequence.STOP_AA);
 30: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 31: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 32: assertEquals(25, AminoAcidSequence.symbol_count);
 33: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 34: assertNotNull(aminoAcidSequence1);
 35: assertEquals("x  ", aminoAcidSequence1.toString());
 36: assertFalse(aminoAcidSequence1.containsStopCodon());
 37: assertEquals(3, aminoAcidSequence1.length());
 38: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 39: 
 40: AminoAcidSequence.setGeneCode();
 41: int int1 = AminoAcidSequence.getSymbolIndex('C');
 42: assertFalse(int1 == int0);
 43: assertEquals(4, int1);
 44: 
 45: AminoAcidSequence.setGeneCode();
 46: int int2 = AminoAcidSequence.getSymbolIndex('N');
 47: assertFalse(int2 == int0);
 48: assertFalse(int2 == int1);
 49: assertEquals(2, int2);

Test case 107

  1: char char0 = AminoAcidSequence.getCodonTranslation("FpH55Y9k7-5\"Kg/");
  2: assertEquals('.', char0);
  3: 
  4: char char1 = AminoAcidSequence.getCodonTranslation('X', 'Q', '|');
  5: assertTrue(char1 == char0);
  6: assertEquals('.', char1);
  7: 
  8: char[] charArray0 = new char[8];
  9: charArray0[0] = '.';
 10: charArray0[1] = 'X';
 11: charArray0[2] = '|';
 12: charArray0[3] = 'X';
 13: charArray0[4] = '.';
 14: charArray0[5] = '.';
 15: charArray0[6] = 'Q';
 16: charArray0[7] = 'X';
 17: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation(charArray0, true);
 18: assertEquals(5, AminoAcidSequence.STOP_AA);
 19: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 20: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 21: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 22: assertEquals(25, AminoAcidSequence.symbol_count);
 23: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 24: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 25: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 26: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 27: assertArrayEquals(new char[] {'.', 'X', '|', 'X', '.', '.', 'Q', 'X'}, charArray0);
 28: assertNotNull(aminoAcidSequence0);
 29: assertEquals(6, aminoAcidSequence0.length());
 30: assertFalse(aminoAcidSequence0.containsStopCodon());
 31: assertEquals("x  x  ", aminoAcidSequence0.toString());
 32: 
 33: AminoAcidSequence.getSymbolIndex('@');

Test case 108

  1: AminoAcidSequence aminoAcidSequence0 = new AminoAcidSequence("feature_labels");
  2: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  3: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  4: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  5: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 10: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(14, aminoAcidSequence0.length());
 13: assertEquals("feature_labels", aminoAcidSequence0.toString());
 14: assertFalse(aminoAcidSequence0.containsStopCodon());
 15: 
 16: Short short0 = new Short((short) (-27006));
 17: assertEquals((short) (-27006), (short)short0);
 18: assertNotNull(short0);
 19: 
 20: PartialSequence partialSequence0 = new PartialSequence(aminoAcidSequence0.codon_translation_array, 0, 7, short0, (Integer) 2);
 21: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 22: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 23: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 24: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 25: assertEquals(25, AminoAcidSequence.symbol_count);
 26: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 27: assertEquals(5, AminoAcidSequence.STOP_AA);
 28: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 29: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 30: assertNotNull(partialSequence0);
 31: assertEquals(14, aminoAcidSequence0.length());
 32: assertEquals("feature_labels", aminoAcidSequence0.toString());
 33: assertFalse(aminoAcidSequence0.containsStopCodon());
 34: assertFalse(partialSequence0.isComplement());
 35: assertEquals((short) (-27006), (short)partialSequence0.getStrand());
 36: assertEquals(0, partialSequence0.getCCount());
 37: assertEquals(0, partialSequence0.length());
 38: assertEquals(2, (int)partialSequence0.getPhase());
 39: assertEquals(64, partialSequence0.getOtherCount());
 40: assertEquals(0, partialSequence0.getTCount());
 41: assertEquals(0, partialSequence0.getACount());
 42: assertEquals(0, partialSequence0.getGCount());
 43: 
 44: Bases bases0 = new Bases(partialSequence0);
 45: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 46: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 47: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 48: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 49: assertEquals(25, AminoAcidSequence.symbol_count);
 50: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 51: assertEquals(5, AminoAcidSequence.STOP_AA);
 52: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 53: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 54: assertEquals(5, Bases.MAX_PRIORITY);
 55: assertEquals(2, Bases.REVERSE);
 56: assertEquals((-5), Bases.MIN_PRIORITY);
 57: assertEquals(0, Bases.MEDIUM_PRIORITY);
 58: assertEquals(1, Bases.FORWARD);
 59: assertNotNull(bases0);
 60: assertEquals(14, aminoAcidSequence0.length());
 61: assertEquals("feature_labels", aminoAcidSequence0.toString());
 62: assertFalse(aminoAcidSequence0.containsStopCodon());
 63: assertFalse(partialSequence0.isComplement());
 64: assertEquals((short) (-27006), (short)partialSequence0.getStrand());
 65: assertEquals(0, partialSequence0.getCCount());
 66: assertEquals(0, partialSequence0.length());
 67: assertEquals(2, (int)partialSequence0.getPhase());
 68: assertEquals(64, partialSequence0.getOtherCount());
 69: assertEquals(0, partialSequence0.getTCount());
 70: assertEquals(0, partialSequence0.getACount());
 71: assertEquals(0, partialSequence0.getGCount());
 72: 
 73: Clipboard clipboard0 = new Clipboard("feature_labels");
 74: assertNotNull(clipboard0);
 75: assertEquals("feature_labels", clipboard0.getName());
 76: 
 77: DataFlavor dataFlavor0 = DataFlavor.allHtmlFlavor;
 78: assertNotNull(dataFlavor0);
 79: assertFalse(dataFlavor0.isRepresentationClassReader());
 80: assertFalse(dataFlavor0.isFlavorJavaFileListType());
 81: assertFalse(dataFlavor0.isRepresentationClassInputStream());
 82: assertFalse(dataFlavor0.isRepresentationClassRemote());
 83: assertEquals("html", dataFlavor0.getSubType());
 84: assertFalse(dataFlavor0.isRepresentationClassCharBuffer());
 85: assertEquals("text/html", dataFlavor0.getHumanPresentableName());
 86: assertTrue(dataFlavor0.isRepresentationClassSerializable());
 87: assertEquals("text", dataFlavor0.getPrimaryType());
 88: assertEquals("text/html; document=all; class=java.lang.String; charset=Unicode", dataFlavor0.getMimeType());
 89: assertFalse(dataFlavor0.isRepresentationClassByteBuffer());
 90: 
 91: boolean boolean0 = clipboard0.isDataFlavorAvailable(dataFlavor0);
 92: assertFalse(boolean0);
 93: assertEquals("feature_labels", clipboard0.getName());
 94: assertFalse(dataFlavor0.isRepresentationClassReader());
 95: assertFalse(dataFlavor0.isFlavorJavaFileListType());
 96: assertFalse(dataFlavor0.isRepresentationClassInputStream());
 97: assertFalse(dataFlavor0.isRepresentationClassRemote());
 98: assertEquals("html", dataFlavor0.getSubType());
 99: assertFalse(dataFlavor0.isRepresentationClassCharBuffer());
100: assertEquals("text/html", dataFlavor0.getHumanPresentableName());
101: assertTrue(dataFlavor0.isRepresentationClassSerializable());
102: assertEquals("text", dataFlavor0.getPrimaryType());
103: assertEquals("text/html; document=all; class=java.lang.String; charset=Unicode", dataFlavor0.getMimeType());
104: assertFalse(dataFlavor0.isRepresentationClassByteBuffer());
105: 
106: Selection selection0 = new Selection(clipboard0);
107: assertNotNull(selection0);
108: assertEquals("feature_labels", clipboard0.getName());
109: 
110: Marker marker0 = selection0.getHighestBaseOfSelection();
111: assertNull(marker0);
112: assertEquals("feature_labels", clipboard0.getName());
113: 
114: MarkerRange markerRange0 = aminoAcidSequence0.findMatch(bases0, (Marker) null, true, true, false);
115: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
116: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
117: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
118: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
119: assertEquals(25, AminoAcidSequence.symbol_count);
120: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
121: assertEquals(5, AminoAcidSequence.STOP_AA);
122: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
123: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
124: assertEquals(5, Bases.MAX_PRIORITY);
125: assertEquals(2, Bases.REVERSE);
126: assertEquals((-5), Bases.MIN_PRIORITY);
127: assertEquals(0, Bases.MEDIUM_PRIORITY);
128: assertEquals(1, Bases.FORWARD);
129: assertNull(markerRange0);
130: assertEquals(14, aminoAcidSequence0.length());
131: assertEquals("feature_labels", aminoAcidSequence0.toString());
132: assertFalse(aminoAcidSequence0.containsStopCodon());
133: assertFalse(partialSequence0.isComplement());
134: assertEquals((short) (-27006), (short)partialSequence0.getStrand());
135: assertEquals(0, partialSequence0.getCCount());
136: assertEquals(0, partialSequence0.length());
137: assertEquals(2, (int)partialSequence0.getPhase());
138: assertEquals(64, partialSequence0.getOtherCount());
139: assertEquals(0, partialSequence0.getTCount());
140: assertEquals(0, partialSequence0.getACount());
141: assertEquals(0, partialSequence0.getGCount());
142: 
143: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("a8{\"", true);
144: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
145: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
146: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
147: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
148: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
149: assertEquals(5, AminoAcidSequence.STOP_AA);
150: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
151: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
152: assertEquals(25, AminoAcidSequence.symbol_count);
153: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
154: assertNotNull(aminoAcidSequence1);
155: assertEquals("x  ", aminoAcidSequence1.toString());
156: assertFalse(aminoAcidSequence1.containsStopCodon());
157: assertEquals(3, aminoAcidSequence1.length());
158: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
159: 
160: int int0 = AminoAcidSequence.getSymbolIndex('S');
161: assertEquals(15, int0);
162: 
163: int int1 = AminoAcidSequence.getAminoAcidType(' ');
164: assertFalse(int1 == int0);
165: assertEquals(7, int1);
166: 
167: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation(bases0.letter_index, false);
168: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
169: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
170: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
171: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
172: assertEquals(25, AminoAcidSequence.symbol_count);
173: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
174: assertEquals(5, AminoAcidSequence.STOP_AA);
175: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
176: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
177: assertEquals(5, Bases.MAX_PRIORITY);
178: assertEquals(2, Bases.REVERSE);
179: assertEquals((-5), Bases.MIN_PRIORITY);
180: assertEquals(0, Bases.MEDIUM_PRIORITY);
181: assertEquals(1, Bases.FORWARD);
182: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
183: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
184: assertEquals(5, AminoAcidSequence.STOP_AA);
185: assertEquals(25, AminoAcidSequence.symbol_count);
186: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
187: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
188: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
189: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
190: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
191: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
192: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
193: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
194: assertNotNull(aminoAcidSequence2);
195: assertEquals(14, aminoAcidSequence0.length());
196: assertEquals("feature_labels", aminoAcidSequence0.toString());
197: assertFalse(aminoAcidSequence0.containsStopCodon());
198: assertFalse(partialSequence0.isComplement());
199: assertEquals((short) (-27006), (short)partialSequence0.getStrand());
200: assertEquals(0, partialSequence0.getCCount());
201: assertEquals(0, partialSequence0.length());
202: assertEquals(2, (int)partialSequence0.getPhase());
203: assertEquals(64, partialSequence0.getOtherCount());
204: assertEquals(0, partialSequence0.getTCount());
205: assertEquals(0, partialSequence0.getACount());
206: assertEquals(0, partialSequence0.getGCount());
207: assertFalse(aminoAcidSequence2.containsStopCodon());
208: assertEquals("s  ", aminoAcidSequence2.toString());
209: assertEquals(3, aminoAcidSequence2.length());
210: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
211: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
212: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
213: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
214: 
215: boolean boolean1 = aminoAcidSequence2.containsStopCodon();
216: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
217: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
218: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
219: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
220: assertEquals(25, AminoAcidSequence.symbol_count);
221: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
222: assertEquals(5, AminoAcidSequence.STOP_AA);
223: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
224: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
225: assertEquals(5, Bases.MAX_PRIORITY);
226: assertEquals(2, Bases.REVERSE);
227: assertEquals((-5), Bases.MIN_PRIORITY);
228: assertEquals(0, Bases.MEDIUM_PRIORITY);
229: assertEquals(1, Bases.FORWARD);
230: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
231: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
232: assertEquals(5, AminoAcidSequence.STOP_AA);
233: assertEquals(25, AminoAcidSequence.symbol_count);
234: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
235: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
236: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
237: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
238: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
239: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence2));
240: assertFalse(aminoAcidSequence0.equals((Object)aminoAcidSequence1));
241: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
242: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
243: assertTrue(boolean1 == boolean0);
244: assertFalse(boolean1);
245: assertEquals(14, aminoAcidSequence0.length());
246: assertEquals("feature_labels", aminoAcidSequence0.toString());
247: assertFalse(aminoAcidSequence0.containsStopCodon());
248: assertFalse(partialSequence0.isComplement());
249: assertEquals((short) (-27006), (short)partialSequence0.getStrand());
250: assertEquals(0, partialSequence0.getCCount());
251: assertEquals(0, partialSequence0.length());
252: assertEquals(2, (int)partialSequence0.getPhase());
253: assertEquals(64, partialSequence0.getOtherCount());
254: assertEquals(0, partialSequence0.getTCount());
255: assertEquals(0, partialSequence0.getACount());
256: assertEquals(0, partialSequence0.getGCount());
257: assertFalse(aminoAcidSequence2.containsStopCodon());
258: assertEquals("s  ", aminoAcidSequence2.toString());
259: assertEquals(3, aminoAcidSequence2.length());
260: assertNotSame(aminoAcidSequence0, aminoAcidSequence2);
261: assertNotSame(aminoAcidSequence0, aminoAcidSequence1);
262: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
263: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
264: 
265: aminoAcidSequence0.getMolecularWeight();

Test case 109

  1: boolean boolean0 = AminoAcidSequence.isLegalCodon('O');
  2: assertFalse(boolean0);
  3: 
  4: char char0 = AminoAcidSequence.getCodonTranslation('3', 'O', '3');
  5: assertEquals('.', char0);

Test case 110

  1: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("bw'x-k4O0-tl", false);
  2: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
  3: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
  4: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
  5: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
  6: assertEquals(25, AminoAcidSequence.symbol_count);
  7: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
  8: assertEquals(5, AminoAcidSequence.STOP_AA);
  9: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 10: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 11: assertNotNull(aminoAcidSequence0);
 12: assertEquals(".  .  .  .  ", aminoAcidSequence0.toString());
 13: assertFalse(aminoAcidSequence0.containsStopCodon());
 14: assertEquals(12, aminoAcidSequence0.length());
 15: 
 16: int int0 = AminoAcidSequence.getSymbolIndex('#');
 17: assertEquals(21, int0);
 18: 
 19: AminoAcidSequence.getSpacedTranslation((char[]) null, false);

Test case 111

  1: String string0 = AminoAcidSequence.getThreeLetterAbbreviation(0);
  2: assertEquals("Ala", string0);
  3: assertNotNull(string0);
  4: 
  5: String string1 = AminoAcidSequence.getThreeLetterAbbreviation('t');
  6: assertFalse(string1.equals((Object)string0));
  7: assertEquals("Thr", string1);
  8: assertNotNull(string1);
  9: 
 10: char char0 = AminoAcidSequence.getCodonTranslation('t', 't', ';');
 11: assertEquals('.', char0);
 12: 
 13: int int0 = AminoAcidSequence.getAminoAcidType('(');
 14: assertEquals(7, int0);
 15: 
 16: AminoAcidSequence aminoAcidSequence0 = AminoAcidSequence.getSpacedTranslation("x)]ru^jkDJ*", false);
 17: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 18: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 19: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 20: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 21: assertEquals(5, AminoAcidSequence.STOP_AA);
 22: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 23: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 24: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 25: assertEquals(25, AminoAcidSequence.symbol_count);
 26: assertNotNull(aminoAcidSequence0);
 27: assertEquals(12, aminoAcidSequence0.length());
 28: assertFalse(aminoAcidSequence0.containsStopCodon());
 29: assertEquals(".  .  .  .  ", aminoAcidSequence0.toString());
 30: 
 31: AminoAcidSequence aminoAcidSequence1 = AminoAcidSequence.getSpacedTranslation("Thr", false);
 32: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 33: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 34: assertEquals(25, AminoAcidSequence.symbol_count);
 35: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 36: assertEquals(5, AminoAcidSequence.STOP_AA);
 37: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 38: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 39: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 40: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 41: assertFalse(aminoAcidSequence1.equals((Object)aminoAcidSequence0));
 42: assertNotNull(aminoAcidSequence1);
 43: assertEquals(3, aminoAcidSequence1.length());
 44: assertEquals(".  ", aminoAcidSequence1.toString());
 45: assertFalse(aminoAcidSequence1.containsStopCodon());
 46: assertNotSame(aminoAcidSequence1, aminoAcidSequence0);
 47: 
 48: AminoAcidSequence aminoAcidSequence2 = AminoAcidSequence.getSpacedTranslation("Ala", true);
 49: assertEquals(2, AminoAcidSequence.NEGATIVELY_CHARGED_AA);
 50: assertEquals(5, AminoAcidSequence.STOP_AA);
 51: assertEquals(0, AminoAcidSequence.POLAR_UNCHARGED_AA);
 52: assertEquals(7, AminoAcidSequence.ILLEGAL_AA);
 53: assertEquals(4, AminoAcidSequence.SPECIAL_AA);
 54: assertEquals(25, AminoAcidSequence.symbol_count);
 55: assertEquals(3, AminoAcidSequence.HYDROPHOBIC_AA);
 56: assertEquals(1, AminoAcidSequence.POSITIVELY_CHARGED_AA);
 57: assertEquals(6, AminoAcidSequence.UNKNOWN_AA);
 58: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence0));
 59: assertFalse(aminoAcidSequence2.equals((Object)aminoAcidSequence1));
 60: assertNotNull(aminoAcidSequence2);
 61: assertEquals("x  ", aminoAcidSequence2.toString());
 62: assertEquals(3, aminoAcidSequence2.length());
 63: assertFalse(aminoAcidSequence2.containsStopCodon());
 64: assertNotSame(aminoAcidSequence2, aminoAcidSequence0);
 65: assertNotSame(aminoAcidSequence2, aminoAcidSequence1);
 66: 
 67: AminoAcidSequence.setGeneCode();
 68: AminoAcidSequence.setGeneCode();
 69: int int1 = AminoAcidSequence.getSymbolIndex('N');
 70: assertFalse(int1 == int0);
 71: assertEquals(2, int1);
 72: 
 73: int int2 = AminoAcidSequence.getAminoAcidType('C');
 74: assertFalse(int2 == int1);
 75: assertFalse(int2 == int0);
 76: assertEquals(4, int2);

Source Code

  1: No source found for uk.ac.sanger.artemis.sequence.AminoAcidSequence

EvoSuite Parameters

  • TARGET_CLASS: uk.ac.sanger.artemis.sequence.AminoAcidSequence
  • Size: 111
  • Length: 806
  • criterion: LINE;BRANCH;EXCEPTION;WEAKMUTATION;OUTPUT;METHOD;METHODNOEXCEPTION;CBRANCH
  • Coverage: 0.7631949200571099
  • BranchCoverage: 0.6625386996904025
  • MethodCoverage: 1.0
  • OutputCoverage: 0.5774647887323944


Back to Overview