Summary

Test suite

Test case 1

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: ActionController actionController0 = simpleEntryGroup0.getActionController();
  3: simpleEntryGroup0.removeEntryChangeListener(actionController0);
  4: assertEquals(0, simpleEntryGroup0.refCount());

Test case 2

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: SimpleEntryGroup.FeatureEnumerator simpleEntryGroup_FeatureEnumerator0 = (SimpleEntryGroup.FeatureEnumerator)simpleEntryGroup0.features();
  3: simpleEntryGroup_FeatureEnumerator0.nextFeature();

Test case 3

  1: GenbankStreamSequence genbankStreamSequence0 = new GenbankStreamSequence("/ ~\"N2q@E+k!\"");
  2: Bases bases0 = new Bases(genbankStreamSequence0);
  3: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
  4: simpleEntryGroup0.getSequenceLength();
  5: assertEquals(0, simpleEntryGroup0.refCount());

Test case 4

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createFeature();

Test case 5

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: int int0 = simpleEntryGroup0.refCount();
  3: assertEquals(0, int0);

Test case 6

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: Entry entry0 = simpleEntryGroup0.createEntry();
  3: simpleEntryGroup0.removeFeatureChangeListener(entry0);

Test case 7

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: Key key0 = Key.CDS;
  3: FeatureKeyPredicate featureKeyPredicate0 = new FeatureKeyPredicate(key0);
  4: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureKeyPredicate0, "Object is not in this ontology: ");
  5: ActionController actionController0 = filteredEntryGroup0.getActionController();
  6: simpleEntryGroup0.removeEntryGroupChangeListener(actionController0);
  7: assertEquals(0, filteredEntryGroup0.refCount());
  8: assertEquals(0, simpleEntryGroup0.refCount());

Test case 8

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: Entry entry0 = simpleEntryGroup0.createEntry("M.ity`KBzoEEELYvL@");
  3: simpleEntryGroup0.setIsActive(entry0, false);
  4: boolean boolean0 = simpleEntryGroup0.remove(entry0);
  5: assertEquals(0, simpleEntryGroup0.refCount());
  6: assertTrue(boolean0);

Test case 9

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: boolean boolean0 = simpleEntryGroup0.hasUnsavedChanges();
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: assertFalse(boolean0);

Test case 10

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: Entry entry0 = simpleEntryGroup0.createEntry("46");
  3: boolean boolean0 = simpleEntryGroup0.removeElement(entry0);
  4: assertTrue(boolean0);
  5: 
  6: simpleEntryGroup0.setDefaultEntry(entry0);
  7: assertEquals(0, simpleEntryGroup0.refCount());

Test case 11

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: int int0 = simpleEntryGroup0.indexOf((Feature) null);
  3: assertEquals((-1), int0);
  4: assertEquals(0, simpleEntryGroup0.refCount());

Test case 12

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: boolean boolean0 = simpleEntryGroup0.contains((Feature) null);
  3: assertFalse(boolean0);
  4: assertEquals(0, simpleEntryGroup0.refCount());

Test case 13

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: Entry entry0 = simpleEntryGroup0.getSequenceEntry();
  4: assertNotNull(entry0);
  5: assertEquals(0, simpleEntryGroup0.refCount());

Test case 14

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.getSequenceEntry();
  3: assertEquals(0, simpleEntryGroup0.refCount());

Test case 15

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.reverseComplement();

Test case 16

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: boolean boolean0 = simpleEntryGroup0.isReadOnly();
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: assertFalse(boolean0);

Test case 17

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.unref();
  3: int int0 = simpleEntryGroup0.refCount();
  4: assertEquals((-1), int0);

Test case 18

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: simpleEntryGroup0.ref();
  4: simpleEntryGroup0.unref();
  5: assertEquals(0, simpleEntryGroup0.refCount());

Test case 19

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.featureAt((-2872));

Test case 20

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: simpleEntryGroup0.getFeaturesInIndexRange(5, 5);

Test case 21

  1: Bases bases0 = new Bases((Sequence) null);
  2: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
  3: simpleEntryGroup0.getFeaturesInIndexRange(5, (-1418));
  4: assertEquals(0, simpleEntryGroup0.refCount());

Test case 22

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: Range range0 = new Range(1167);
  4: simpleEntryGroup0.getFeaturesInRange(range0);
  5: assertEquals(0, simpleEntryGroup0.refCount());

Test case 23

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry("Overlaying a GFF with a sequence onto an entry with a sequence.");
  3: simpleEntryGroup0.getAllFeatures();
  4: assertEquals(0, simpleEntryGroup0.refCount());

Test case 24

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: simpleEntryGroup0.createEntry();
  3: int int0 = simpleEntryGroup0.getAllFeaturesCount();
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: assertEquals(0, int0);

Test case 25

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Key key0 = Key.CDS;
  7: assertNotNull(key0);
  8: assertEquals("CDS", key0.toString());
  9: assertEquals(3, key0.length());
 10: assertEquals("CDS", key0.getKeyString());
 11: 
 12: FeatureKeyQualifierPredicate featureKeyQualifierPredicate0 = new FeatureKeyQualifierPredicate(key0, "sP", false);
 13: assertNotNull(featureKeyQualifierPredicate0);
 14: assertEquals("CDS", key0.toString());
 15: assertEquals(3, key0.length());
 16: assertEquals("CDS", key0.getKeyString());
 17: 
 18: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureKeyQualifierPredicate0, "sP");
 19: assertNotNull(filteredEntryGroup0);
 20: assertEquals(0, simpleEntryGroup0.size());
 21: assertEquals(0, simpleEntryGroup0.refCount());
 22: assertEquals("CDS", key0.toString());
 23: assertEquals(3, key0.length());
 24: assertEquals("CDS", key0.getKeyString());
 25: assertEquals(0, filteredEntryGroup0.size());
 26: assertEquals("sP", filteredEntryGroup0.getFilterName());
 27: assertEquals(0, filteredEntryGroup0.refCount());
 28: 
 29: Entry entry0 = filteredEntryGroup0.createEntry("Warning");
 30: assertNotNull(entry0);
 31: assertEquals(0, simpleEntryGroup0.refCount());
 32: assertEquals(1, simpleEntryGroup0.size());
 33: assertEquals("CDS", key0.toString());
 34: assertEquals(3, key0.length());
 35: assertEquals("CDS", key0.getKeyString());
 36: assertEquals(1, filteredEntryGroup0.size());
 37: assertEquals("sP", filteredEntryGroup0.getFilterName());
 38: assertEquals(0, filteredEntryGroup0.refCount());
 39: assertFalse(entry0.isReadOnly());
 40: 
 41: simpleEntryGroup0.addElement(entry0);
 42: assertEquals(0, simpleEntryGroup0.refCount());
 43: assertEquals(1, simpleEntryGroup0.size());
 44: assertEquals("CDS", key0.toString());
 45: assertEquals(3, key0.length());
 46: assertEquals("CDS", key0.getKeyString());
 47: assertEquals(1, filteredEntryGroup0.size());
 48: assertEquals("sP", filteredEntryGroup0.getFilterName());
 49: assertEquals(0, filteredEntryGroup0.refCount());
 50: assertFalse(entry0.isReadOnly());

Test case 26

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry();
  7: assertNotNull(entry0);
  8: assertEquals(1, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: simpleEntryGroup0.createEntry();

Test case 27

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry();
  7: assertNotNull(entry0);
  8: assertEquals(0, simpleEntryGroup0.refCount());
  9: assertEquals(1, simpleEntryGroup0.size());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: SimpleEntryGroup.FeatureEnumerator simpleEntryGroup_FeatureEnumerator0 = (SimpleEntryGroup.FeatureEnumerator)simpleEntryGroup0.features();
 13: assertNotNull(simpleEntryGroup_FeatureEnumerator0);
 14: assertEquals(0, simpleEntryGroup0.refCount());
 15: assertEquals(1, simpleEntryGroup0.size());

Test case 28

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry();
  7: assertNotNull(entry0);
  8: assertEquals(0, simpleEntryGroup0.refCount());
  9: assertEquals(1, simpleEntryGroup0.size());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: SimpleEntryGroup.FeatureEnumerator simpleEntryGroup_FeatureEnumerator0 = simpleEntryGroup0.new FeatureEnumerator();
 13: assertNotNull(simpleEntryGroup_FeatureEnumerator0);
 14: assertEquals(0, simpleEntryGroup0.refCount());
 15: assertEquals(1, simpleEntryGroup0.size());
 16: 
 17: boolean boolean0 = simpleEntryGroup_FeatureEnumerator0.hasMoreFeatures();
 18: assertFalse(boolean0);
 19: assertEquals(0, simpleEntryGroup0.refCount());
 20: assertEquals(1, simpleEntryGroup0.size());
 21: 
 22: simpleEntryGroup_FeatureEnumerator0.hasMoreFeatures();

Test case 29

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: SimpleEntryGroup.FeatureEnumerator simpleEntryGroup_FeatureEnumerator0 = simpleEntryGroup0.new FeatureEnumerator();
  7: assertNotNull(simpleEntryGroup_FeatureEnumerator0);
  8: assertEquals(0, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());
 10: 
 11: boolean boolean0 = simpleEntryGroup_FeatureEnumerator0.hasMoreFeatures();
 12: assertFalse(boolean0);
 13: assertEquals(0, simpleEntryGroup0.size());
 14: assertEquals(0, simpleEntryGroup0.refCount());

Test case 30

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry();
  7: assertNotNull(entry0);
  8: assertEquals(1, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: SimpleEntryGroup.FeatureEnumerator simpleEntryGroup_FeatureEnumerator0 = simpleEntryGroup0.new FeatureEnumerator();
 13: assertNotNull(simpleEntryGroup_FeatureEnumerator0);
 14: assertEquals(1, simpleEntryGroup0.size());
 15: assertEquals(0, simpleEntryGroup0.refCount());
 16: 
 17: simpleEntryGroup_FeatureEnumerator0.nextFeature();

Test case 31

  1: Bases bases0 = new Bases((Sequence) null);
  2: assertNotNull(bases0);
  3: assertEquals((-5), Bases.MIN_PRIORITY);
  4: assertEquals(0, Bases.MEDIUM_PRIORITY);
  5: assertEquals(1, Bases.FORWARD);
  6: assertEquals(5, Bases.MAX_PRIORITY);
  7: assertEquals(2, Bases.REVERSE);
  8: 
  9: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
 10: assertNotNull(simpleEntryGroup0);
 11: assertEquals((-5), Bases.MIN_PRIORITY);
 12: assertEquals(0, Bases.MEDIUM_PRIORITY);
 13: assertEquals(1, Bases.FORWARD);
 14: assertEquals(5, Bases.MAX_PRIORITY);
 15: assertEquals(2, Bases.REVERSE);
 16: assertEquals(0, simpleEntryGroup0.refCount());
 17: assertEquals(0, simpleEntryGroup0.size());
 18: 
 19: simpleEntryGroup0.entryChanged((EntryChangeEvent) null);
 20: assertEquals((-5), Bases.MIN_PRIORITY);
 21: assertEquals(0, Bases.MEDIUM_PRIORITY);
 22: assertEquals(1, Bases.FORWARD);
 23: assertEquals(5, Bases.MAX_PRIORITY);
 24: assertEquals(2, Bases.REVERSE);
 25: assertEquals(0, simpleEntryGroup0.refCount());
 26: assertEquals(0, simpleEntryGroup0.size());

Test case 32

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: ActionController actionController0 = simpleEntryGroup0.getActionController();
  7: assertNotNull(actionController0);
  8: assertEquals(0, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());
 10: assertFalse(actionController0.canUndo());
 11: 
 12: simpleEntryGroup0.addEntryChangeListener(actionController0);
 13: assertEquals(0, simpleEntryGroup0.size());
 14: assertEquals(0, simpleEntryGroup0.refCount());
 15: assertFalse(actionController0.canUndo());

Test case 33

  1: Bases bases0 = new Bases((Sequence) null);
  2: assertNotNull(bases0);
  3: assertEquals(0, Bases.MEDIUM_PRIORITY);
  4: assertEquals(1, Bases.FORWARD);
  5: assertEquals((-5), Bases.MIN_PRIORITY);
  6: assertEquals(5, Bases.MAX_PRIORITY);
  7: assertEquals(2, Bases.REVERSE);
  8: 
  9: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
 10: assertNotNull(simpleEntryGroup0);
 11: assertEquals(0, Bases.MEDIUM_PRIORITY);
 12: assertEquals(1, Bases.FORWARD);
 13: assertEquals((-5), Bases.MIN_PRIORITY);
 14: assertEquals(5, Bases.MAX_PRIORITY);
 15: assertEquals(2, Bases.REVERSE);
 16: assertEquals(0, simpleEntryGroup0.refCount());
 17: assertEquals(0, simpleEntryGroup0.size());
 18: 
 19: EntryVector entryVector0 = simpleEntryGroup0.getActiveEntries();
 20: assertNotNull(entryVector0);
 21: assertEquals(0, Bases.MEDIUM_PRIORITY);
 22: assertEquals(1, Bases.FORWARD);
 23: assertEquals((-5), Bases.MIN_PRIORITY);
 24: assertEquals(5, Bases.MAX_PRIORITY);
 25: assertEquals(2, Bases.REVERSE);
 26: assertEquals(0, simpleEntryGroup0.refCount());
 27: assertEquals(0, simpleEntryGroup0.size());
 28: assertEquals(0, entryVector0.size());

Test case 34

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Bases bases0 = simpleEntryGroup0.getBases();
  7: assertNull(bases0);
  8: assertEquals(0, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());

Test case 35

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Entry entry0 = simpleEntryGroup0.getDefaultEntry();
  7: assertNull(entry0);
  8: assertEquals(0, simpleEntryGroup0.refCount());
  9: assertEquals(0, simpleEntryGroup0.size());

Test case 36

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: FeatureVector featureVector0 = new FeatureVector();
  7: assertNotNull(featureVector0);
  8: 
  9: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureVector0, "s;m9>i\"~d[m\">gp");
 10: assertNotNull(filteredEntryGroup0);
 11: assertEquals(0, simpleEntryGroup0.size());
 12: assertEquals(0, simpleEntryGroup0.refCount());
 13: assertEquals(0, filteredEntryGroup0.refCount());
 14: assertEquals(0, filteredEntryGroup0.size());
 15: assertEquals("s;m9>i\"~d[m\">gp", filteredEntryGroup0.getFilterName());
 16: 
 17: Entry entry0 = filteredEntryGroup0.createEntry("s;m9>i\"~d[m\">gp");
 18: assertNotNull(entry0);
 19: assertEquals(1, simpleEntryGroup0.size());
 20: assertEquals(0, simpleEntryGroup0.refCount());
 21: assertEquals(0, filteredEntryGroup0.refCount());
 22: assertEquals(1, filteredEntryGroup0.size());
 23: assertEquals("s;m9>i\"~d[m\">gp", filteredEntryGroup0.getFilterName());
 24: assertFalse(entry0.isReadOnly());
 25: 
 26: simpleEntryGroup0.addFeatureChangeListener(entry0);
 27: assertEquals(1, simpleEntryGroup0.size());
 28: assertEquals(0, simpleEntryGroup0.refCount());
 29: assertEquals(0, filteredEntryGroup0.refCount());
 30: assertEquals(1, filteredEntryGroup0.size());
 31: assertEquals("s;m9>i\"~d[m\">gp", filteredEntryGroup0.getFilterName());
 32: assertFalse(entry0.isReadOnly());

Test case 37

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Selection selection0 = new Selection((Clipboard) null);
  7: assertNotNull(selection0);
  8: 
  9: FeatureVector featureVector0 = selection0.getAllFeatures();
 10: assertNotNull(featureVector0);
 11: 
 12: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureVector0, "vJMxKhS{zxVtM");
 13: assertNotNull(filteredEntryGroup0);
 14: assertEquals(0, simpleEntryGroup0.refCount());
 15: assertEquals(0, simpleEntryGroup0.size());
 16: assertEquals("vJMxKhS{zxVtM", filteredEntryGroup0.getFilterName());
 17: assertEquals(0, filteredEntryGroup0.refCount());
 18: assertEquals(0, filteredEntryGroup0.size());
 19: 
 20: Entry entry0 = filteredEntryGroup0.createEntry("vJMxKhS{zxVtM");
 21: assertNotNull(entry0);
 22: assertEquals(0, simpleEntryGroup0.refCount());
 23: assertEquals(1, simpleEntryGroup0.size());
 24: assertEquals("vJMxKhS{zxVtM", filteredEntryGroup0.getFilterName());
 25: assertEquals(0, filteredEntryGroup0.refCount());
 26: assertEquals(1, filteredEntryGroup0.size());
 27: assertFalse(entry0.isReadOnly());
 28: 
 29: simpleEntryGroup0.setDefaultEntry(entry0);
 30: assertEquals(0, simpleEntryGroup0.refCount());
 31: assertEquals(1, simpleEntryGroup0.size());
 32: assertEquals("vJMxKhS{zxVtM", filteredEntryGroup0.getFilterName());
 33: assertEquals(0, filteredEntryGroup0.refCount());
 34: assertEquals(1, filteredEntryGroup0.size());
 35: assertFalse(entry0.isReadOnly());

Test case 38

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: boolean boolean0 = simpleEntryGroup0.isActive((Entry) null);
  7: assertFalse(boolean0);
  8: assertEquals(0, simpleEntryGroup0.refCount());
  9: assertEquals(0, simpleEntryGroup0.size());

Test case 39

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry("");
  7: assertNotNull(entry0);
  8: assertEquals(0, simpleEntryGroup0.refCount());
  9: assertEquals(1, simpleEntryGroup0.size());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: boolean boolean0 = simpleEntryGroup0.isActive(entry0);
 13: assertTrue(boolean0);
 14: assertEquals(0, simpleEntryGroup0.refCount());
 15: assertEquals(1, simpleEntryGroup0.size());
 16: assertFalse(entry0.isReadOnly());

Test case 40

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.featureAt(2312);

Test case 41

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry();
  7: assertNotNull(entry0);
  8: assertEquals(0, simpleEntryGroup0.refCount());
  9: assertEquals(1, simpleEntryGroup0.size());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: boolean boolean0 = simpleEntryGroup0.remove(entry0);
 13: assertTrue(boolean0);
 14: assertEquals(0, simpleEntryGroup0.size());
 15: assertEquals(0, simpleEntryGroup0.refCount());
 16: assertFalse(entry0.isReadOnly());
 17: 
 18: simpleEntryGroup0.addElement(entry0);
 19: assertEquals(0, simpleEntryGroup0.refCount());
 20: assertEquals(1, simpleEntryGroup0.size());
 21: assertFalse(entry0.isReadOnly());

Test case 42

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Key key0 = new Key("q7,L9'\"uf?S/X?TG'");
  7: assertNotNull(key0);
  8: assertEquals("q7,L9'\"uf?S/X?TG'", key0.toString());
  9: assertEquals(17, key0.length());
 10: assertEquals("q7,L9'\"uf?S/X?TG'", key0.getKeyString());
 11: 
 12: FeatureKeyQualifierPredicate featureKeyQualifierPredicate0 = new FeatureKeyQualifierPredicate(key0, "q7,L9'\"uf?S/X?TG'");
 13: assertNotNull(featureKeyQualifierPredicate0);
 14: assertEquals("q7,L9'\"uf?S/X?TG'", key0.toString());
 15: assertEquals(17, key0.length());
 16: assertEquals("q7,L9'\"uf?S/X?TG'", key0.getKeyString());
 17: 
 18: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureKeyQualifierPredicate0, "%]cF-42!!i");
 19: assertNotNull(filteredEntryGroup0);
 20: assertEquals(0, simpleEntryGroup0.refCount());
 21: assertEquals(0, simpleEntryGroup0.size());
 22: assertEquals("q7,L9'\"uf?S/X?TG'", key0.toString());
 23: assertEquals(17, key0.length());
 24: assertEquals("q7,L9'\"uf?S/X?TG'", key0.getKeyString());
 25: assertEquals(0, filteredEntryGroup0.size());
 26: assertEquals(0, filteredEntryGroup0.refCount());
 27: assertEquals("%]cF-42!!i", filteredEntryGroup0.getFilterName());
 28: 
 29: Entry entry0 = filteredEntryGroup0.createEntry("Cannot apply changes: ");
 30: assertNotNull(entry0);
 31: assertEquals(0, simpleEntryGroup0.refCount());
 32: assertEquals(1, simpleEntryGroup0.size());
 33: assertEquals("q7,L9'\"uf?S/X?TG'", key0.toString());
 34: assertEquals(17, key0.length());
 35: assertEquals("q7,L9'\"uf?S/X?TG'", key0.getKeyString());
 36: assertEquals(1, filteredEntryGroup0.size());
 37: assertEquals(0, filteredEntryGroup0.refCount());
 38: assertEquals("%]cF-42!!i", filteredEntryGroup0.getFilterName());
 39: assertFalse(entry0.isReadOnly());
 40: 
 41: simpleEntryGroup0.add(entry0);
 42: assertEquals(0, simpleEntryGroup0.refCount());
 43: assertEquals(1, simpleEntryGroup0.size());
 44: assertEquals("q7,L9'\"uf?S/X?TG'", key0.toString());
 45: assertEquals(17, key0.length());
 46: assertEquals("q7,L9'\"uf?S/X?TG'", key0.getKeyString());
 47: assertEquals(1, filteredEntryGroup0.size());
 48: assertEquals(0, filteredEntryGroup0.refCount());
 49: assertEquals("%]cF-42!!i", filteredEntryGroup0.getFilterName());
 50: assertFalse(entry0.isReadOnly());

Test case 43

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup((Bases) null);

Test case 44

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.add((Entry) null);

Test case 45

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.addElement((Entry) null);

Test case 46

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry("Warning");
  7: assertNotNull(entry0);
  8: assertEquals(1, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: simpleEntryGroup0.createEntry("Overlaying a GFF with a sequence onto an entry with a sequence.");

Test case 47

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Key key0 = Key.CDS;
  7: assertNotNull(key0);
  8: assertEquals("CDS", key0.getKeyString());
  9: assertEquals(3, key0.length());
 10: assertEquals("CDS", key0.toString());
 11: 
 12: FeatureKeyPredicate featureKeyPredicate0 = new FeatureKeyPredicate(key0);
 13: assertNotNull(featureKeyPredicate0);
 14: assertEquals("CDS", key0.getKeyString());
 15: assertEquals(3, key0.length());
 16: assertEquals("CDS", key0.toString());
 17: 
 18: FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(simpleEntryGroup0, featureKeyPredicate0, "Object is not in this ontology: ");
 19: assertNotNull(filteredEntryGroup0);
 20: assertEquals(0, simpleEntryGroup0.size());
 21: assertEquals(0, simpleEntryGroup0.refCount());
 22: assertEquals("CDS", key0.getKeyString());
 23: assertEquals(3, key0.length());
 24: assertEquals("CDS", key0.toString());
 25: assertEquals("Object is not in this ontology: ", filteredEntryGroup0.getFilterName());
 26: assertEquals(0, filteredEntryGroup0.size());
 27: assertEquals(0, filteredEntryGroup0.refCount());
 28: 
 29: simpleEntryGroup0.entryChanged((EntryChangeEvent) null);

Test case 48

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: simpleEntryGroup0.getSequenceLength();

Test case 49

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.removeElement((Entry) null);

Test case 50

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.setIsActive(2312, true);

Test case 51

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.setIsActive((Entry) null, false);

Test case 52

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: Range range0 = new Range((-2561));
  7: assertNotNull(range0);
  8: assertEquals(1, range0.getCount());
  9: assertEquals((-2561), range0.getStart());
 10: assertEquals((-2561), range0.getEnd());
 11: 
 12: simpleEntryGroup0.truncate(range0);

Test case 53

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.refCount());
  4: assertEquals(0, simpleEntryGroup0.size());
  5: 
  6: simpleEntryGroup0.ref();
  7: assertEquals(1, simpleEntryGroup0.refCount());
  8: assertEquals(0, simpleEntryGroup0.size());
  9: 
 10: simpleEntryGroup0.addEntryGroupChangeListener((EntryGroupChangeListener) null);
 11: assertEquals(1, simpleEntryGroup0.refCount());
 12: assertEquals(0, simpleEntryGroup0.size());
 13: 
 14: simpleEntryGroup0.unref();

Test case 54

  1: EmblStreamSequence emblStreamSequence0 = new EmblStreamSequence("5_3Xe<vy\"?Ro)bhS");
  2: assertNotNull(emblStreamSequence0);
  3: assertEquals(0, emblStreamSequence0.getACount());
  4: assertEquals(1, emblStreamSequence0.getFormatType());
  5: assertEquals(0, emblStreamSequence0.getCCount());
  6: assertEquals(0, emblStreamSequence0.getTCount());
  7: assertEquals(16, emblStreamSequence0.getOtherCount());
  8: assertEquals(16, emblStreamSequence0.length());
  9: assertNull(emblStreamSequence0.getHeader());
 10: assertEquals(0, emblStreamSequence0.getGCount());
 11: 
 12: RawStreamSequence rawStreamSequence0 = new RawStreamSequence(emblStreamSequence0);
 13: assertNotNull(rawStreamSequence0);
 14: assertEquals(0, emblStreamSequence0.getACount());
 15: assertEquals(1, emblStreamSequence0.getFormatType());
 16: assertEquals(0, emblStreamSequence0.getCCount());
 17: assertEquals(0, emblStreamSequence0.getTCount());
 18: assertEquals(16, emblStreamSequence0.getOtherCount());
 19: assertEquals(16, emblStreamSequence0.length());
 20: assertNull(emblStreamSequence0.getHeader());
 21: assertEquals(0, emblStreamSequence0.getGCount());
 22: assertEquals(3, rawStreamSequence0.getFormatType());
 23: assertEquals(0, rawStreamSequence0.getGCount());
 24: assertEquals(16, rawStreamSequence0.getOtherCount());
 25: assertEquals(0, rawStreamSequence0.getCCount());
 26: assertEquals(0, rawStreamSequence0.getTCount());
 27: assertEquals(16, rawStreamSequence0.length());
 28: assertEquals(0, rawStreamSequence0.getACount());
 29: 
 30: Bases bases0 = new Bases(rawStreamSequence0);
 31: assertNotNull(bases0);
 32: assertEquals((-5), Bases.MIN_PRIORITY);
 33: assertEquals(0, Bases.MEDIUM_PRIORITY);
 34: assertEquals(5, Bases.MAX_PRIORITY);
 35: assertEquals(1, Bases.FORWARD);
 36: assertEquals(2, Bases.REVERSE);
 37: assertEquals(0, emblStreamSequence0.getACount());
 38: assertEquals(1, emblStreamSequence0.getFormatType());
 39: assertEquals(0, emblStreamSequence0.getCCount());
 40: assertEquals(0, emblStreamSequence0.getTCount());
 41: assertEquals(16, emblStreamSequence0.getOtherCount());
 42: assertEquals(16, emblStreamSequence0.length());
 43: assertNull(emblStreamSequence0.getHeader());
 44: assertEquals(0, emblStreamSequence0.getGCount());
 45: assertEquals(3, rawStreamSequence0.getFormatType());
 46: assertEquals(0, rawStreamSequence0.getGCount());
 47: assertEquals(16, rawStreamSequence0.getOtherCount());
 48: assertEquals(0, rawStreamSequence0.getCCount());
 49: assertEquals(0, rawStreamSequence0.getTCount());
 50: assertEquals(16, rawStreamSequence0.length());
 51: assertEquals(0, rawStreamSequence0.getACount());
 52: assertEquals(16, bases0.getLength());
 53: 
 54: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup(bases0);
 55: assertNotNull(simpleEntryGroup0);
 56: assertEquals((-5), Bases.MIN_PRIORITY);
 57: assertEquals(0, Bases.MEDIUM_PRIORITY);
 58: assertEquals(5, Bases.MAX_PRIORITY);
 59: assertEquals(1, Bases.FORWARD);
 60: assertEquals(2, Bases.REVERSE);
 61: assertEquals(0, emblStreamSequence0.getACount());
 62: assertEquals(1, emblStreamSequence0.getFormatType());
 63: assertEquals(0, emblStreamSequence0.getCCount());
 64: assertEquals(0, emblStreamSequence0.getTCount());
 65: assertEquals(16, emblStreamSequence0.getOtherCount());
 66: assertEquals(16, emblStreamSequence0.length());
 67: assertNull(emblStreamSequence0.getHeader());
 68: assertEquals(0, emblStreamSequence0.getGCount());
 69: assertEquals(3, rawStreamSequence0.getFormatType());
 70: assertEquals(0, rawStreamSequence0.getGCount());
 71: assertEquals(16, rawStreamSequence0.getOtherCount());
 72: assertEquals(0, rawStreamSequence0.getCCount());
 73: assertEquals(0, rawStreamSequence0.getTCount());
 74: assertEquals(16, rawStreamSequence0.length());
 75: assertEquals(0, rawStreamSequence0.getACount());
 76: assertEquals(16, bases0.getLength());
 77: assertEquals(0, simpleEntryGroup0.refCount());
 78: assertEquals(16, simpleEntryGroup0.getSequenceLength());
 79: assertEquals(0, simpleEntryGroup0.size());
 80: 
 81: Entry entry0 = simpleEntryGroup0.createEntry();
 82: assertNotNull(entry0);
 83: assertEquals((-5), Bases.MIN_PRIORITY);
 84: assertEquals(0, Bases.MEDIUM_PRIORITY);
 85: assertEquals(5, Bases.MAX_PRIORITY);
 86: assertEquals(1, Bases.FORWARD);
 87: assertEquals(2, Bases.REVERSE);
 88: assertEquals(0, emblStreamSequence0.getACount());
 89: assertEquals(1, emblStreamSequence0.getFormatType());
 90: assertEquals(0, emblStreamSequence0.getCCount());
 91: assertEquals(0, emblStreamSequence0.getTCount());
 92: assertEquals(16, emblStreamSequence0.getOtherCount());
 93: assertEquals(16, emblStreamSequence0.length());
 94: assertNull(emblStreamSequence0.getHeader());
 95: assertEquals(0, emblStreamSequence0.getGCount());
 96: assertEquals(3, rawStreamSequence0.getFormatType());
 97: assertEquals(0, rawStreamSequence0.getGCount());
 98: assertEquals(16, rawStreamSequence0.getOtherCount());
 99: assertEquals(0, rawStreamSequence0.getCCount());
100: assertEquals(0, rawStreamSequence0.getTCount());
101: assertEquals(16, rawStreamSequence0.length());
102: assertEquals(0, rawStreamSequence0.getACount());
103: assertEquals(16, bases0.getLength());
104: assertEquals(0, simpleEntryGroup0.refCount());
105: assertEquals(1, simpleEntryGroup0.size());
106: assertEquals(16, simpleEntryGroup0.getSequenceLength());
107: assertFalse(entry0.isReadOnly());
108: 
109: Entry entry1 = simpleEntryGroup0.getDefaultEntry();
110: assertNotNull(entry1);
111: assertEquals((-5), Bases.MIN_PRIORITY);
112: assertEquals(0, Bases.MEDIUM_PRIORITY);
113: assertEquals(5, Bases.MAX_PRIORITY);
114: assertEquals(1, Bases.FORWARD);
115: assertEquals(2, Bases.REVERSE);
116: assertSame(entry1, entry0);
117: assertEquals(0, emblStreamSequence0.getACount());
118: assertEquals(1, emblStreamSequence0.getFormatType());
119: assertEquals(0, emblStreamSequence0.getCCount());
120: assertEquals(0, emblStreamSequence0.getTCount());
121: assertEquals(16, emblStreamSequence0.getOtherCount());
122: assertEquals(16, emblStreamSequence0.length());
123: assertNull(emblStreamSequence0.getHeader());
124: assertEquals(0, emblStreamSequence0.getGCount());
125: assertEquals(3, rawStreamSequence0.getFormatType());
126: assertEquals(0, rawStreamSequence0.getGCount());
127: assertEquals(16, rawStreamSequence0.getOtherCount());
128: assertEquals(0, rawStreamSequence0.getCCount());
129: assertEquals(0, rawStreamSequence0.getTCount());
130: assertEquals(16, rawStreamSequence0.length());
131: assertEquals(0, rawStreamSequence0.getACount());
132: assertEquals(16, bases0.getLength());
133: assertEquals(0, simpleEntryGroup0.refCount());
134: assertEquals(1, simpleEntryGroup0.size());
135: assertEquals(16, simpleEntryGroup0.getSequenceLength());
136: assertFalse(entry1.isReadOnly());

Test case 55

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.ref();
  7: assertEquals(0, simpleEntryGroup0.size());
  8: assertEquals(1, simpleEntryGroup0.refCount());
  9: 
 10: int int0 = simpleEntryGroup0.refCount();
 11: assertEquals(1, int0);
 12: assertEquals(0, simpleEntryGroup0.size());
 13: assertEquals(1, simpleEntryGroup0.refCount());

Test case 56

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: Entry entry0 = simpleEntryGroup0.createEntry();
  7: assertNotNull(entry0);
  8: assertEquals(1, simpleEntryGroup0.size());
  9: assertEquals(0, simpleEntryGroup0.refCount());
 10: assertFalse(entry0.isReadOnly());
 11: 
 12: simpleEntryGroup0.getFeaturesInIndexRange(0, 0);

Test case 57

  1: SimpleEntryGroup simpleEntryGroup0 = new SimpleEntryGroup();
  2: assertNotNull(simpleEntryGroup0);
  3: assertEquals(0, simpleEntryGroup0.size());
  4: assertEquals(0, simpleEntryGroup0.refCount());
  5: 
  6: simpleEntryGroup0.getFeaturesInIndexRange((-481), 0);

Source Code

  1: No source found for uk.ac.sanger.artemis.SimpleEntryGroup

EvoSuite Parameters

  • TARGET_CLASS: uk.ac.sanger.artemis.SimpleEntryGroup
  • Size: 57
  • Length: 180
  • criterion: LINE;BRANCH;EXCEPTION;WEAKMUTATION;OUTPUT;METHOD;METHODNOEXCEPTION;CBRANCH
  • Coverage: 0.6633870155044571
  • BranchCoverage: 0.5696969696969697
  • MethodCoverage: 0.9777777777777777
  • OutputCoverage: 0.36619718309859156


Back to Overview