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);