/*
 * This file was automatically generated by EvoSuite
 * Wed Sep 19 19:10:41 GMT 2018
 */

package uk.ac.sanger.artemis;

import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.shaded.org.mockito.Mockito.*;
import static org.evosuite.runtime.EvoAssertions.*;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.evosuite.runtime.ViolatedAssumptionAnswer;
import org.junit.runner.RunWith;
import uk.ac.sanger.artemis.ActionController;
import uk.ac.sanger.artemis.Entry;
import uk.ac.sanger.artemis.EntryChangeEvent;
import uk.ac.sanger.artemis.EntryChangeListener;
import uk.ac.sanger.artemis.EntryGroup;
import uk.ac.sanger.artemis.EntryGroupChangeEvent;
import uk.ac.sanger.artemis.EntryGroupChangeListener;
import uk.ac.sanger.artemis.EntryVector;
import uk.ac.sanger.artemis.Feature;
import uk.ac.sanger.artemis.FeatureChangeEvent;
import uk.ac.sanger.artemis.FeatureChangeListener;
import uk.ac.sanger.artemis.FeatureEnumeration;
import uk.ac.sanger.artemis.FeaturePredicate;
import uk.ac.sanger.artemis.FeatureVector;
import uk.ac.sanger.artemis.FilteredEntryGroup;
import uk.ac.sanger.artemis.io.Range;
import uk.ac.sanger.artemis.sequence.Bases;

@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = false, useJEE = true) 
public class FilteredEntryGroup_ESTest extends FilteredEntryGroup_ESTest_scaffolding {

  @Test(timeout = 4000)
  public void test00()  throws Throwable  {
      int int0 = 2;
      Entry entry0 = mock(Entry.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(entry0).toString();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("uk.ac.sanger.artemis.FilteredEntryGroup$3", "uk.ac.sanger.artemis.FilteredEntryGroup$3", ")", ")", "9(68PMPFeKp+2y!p").when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      doReturn(entry0).when(entryGroup0).getDefaultEntry();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      filteredEntryGroup1.getDefaultEntry();
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "uk.ac.sanger.artemis.FilteredEntryGroup$3", "9(68PMPFeKp+2y!p", "").when(entryGroup1).toString();
      doReturn(true).when(entryGroup1).isReadOnly();
      filteredEntryGroup0.createEntry();
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      String string0 = "uk.ac.sanger.artemis.FilteredEntryGroup";
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, featurePredicate1, "uk.ac.sanger.artemis.FilteredEntryGroup");
      filteredEntryGroup2.isReadOnly();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      // Undeclared exception!
      try { 
        filteredEntryGroup0.filterFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test01()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, ", ");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, ", ");
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup1, featurePredicate1, ", ");
      int int0 = (-1645);
      filteredEntryGroup0.addFeatureChangeListener(filteredEntryGroup1);
      filteredEntryGroup2.elementAt((-1645));
      filteredEntryGroup1.add((Entry) null);
      filteredEntryGroup2.isActive((Entry) null);
      filteredEntryGroup0.createFeature();
      filteredEntryGroup1.setDefaultEntry((Entry) null);
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup0.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test02()  throws Throwable  {
      Entry entry0 = mock(Entry.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(entry0).toString();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("2dBWbxZ", "2dBWbxZ", "2dBWbxZ", "uk.ac.sanger.artemis.FilteredEntryGroup$3", "").when(entryGroup0).toString();
      doReturn(entry0).when(entryGroup0).createEntry(anyString());
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn(featureVector0).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, "Warning - unknown keys");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector1, "N0S");
      Entry entry1 = filteredEntryGroup1.createEntry("");
      filteredEntryGroup1.setDefaultEntry(entry1);
      filteredEntryGroup0.removeEntryChangeListener(filteredEntryGroup1);
      filteredEntryGroup1.getFeaturesInRange((Range) null);
      filteredEntryGroup0.createFeature();
      // Undeclared exception!
      try { 
        filteredEntryGroup0.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test03()  throws Throwable  {
      Entry entry0 = mock(Entry.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(entry0).toString();
      ActionController actionController0 = mock(ActionController.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(actionController0).toString();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("x+P", "x+P", "x+P", "x+P", "vj6`y_`").when(entryGroup0).toString();
      doReturn(entry0).when(entryGroup0).createEntry();
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      doReturn(actionController0).when(entryGroup0).getActionController();
      doReturn(featureVector0).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector1, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      Entry entry1 = filteredEntryGroup1.createEntry();
      filteredEntryGroup1.isActive(entry1);
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate1, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup2.entryChanged(entryChangeEvent0);
      ActionController actionController1 = filteredEntryGroup2.getActionController();
      filteredEntryGroup0.removeEntryGroupChangeListener(actionController1);
      filteredEntryGroup0.reverseComplement();
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.getFeaturesInRange(range0);
      filteredEntryGroup1.addEntryChangeListener(filteredEntryGroup0);
      filteredEntryGroup0.addEntryChangeListener(filteredEntryGroup1);
      filteredEntryGroup1.reverseComplement();
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getAllFeaturesCount();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test04()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, "Warning - unknown keys");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "N0S");
      filteredEntryGroup1.createEntry("");
      filteredEntryGroup1.setDefaultEntry((Entry) null);
      filteredEntryGroup0.removeEntryChangeListener(filteredEntryGroup1);
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getFeaturesInRange((Range) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test05()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "0v0uFAPl)Y.t'ZP+}");
      filteredEntryGroup1.createEntry();
      filteredEntryGroup0.createFeature();
      filteredEntryGroup0.getActionController();
      filteredEntryGroup0.getActiveEntries();
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "=_X|vBKjPtJyE$!*rP", "0v0uFAPl)Y.t'ZP+}", "").when(entryGroup1).toString();
      doReturn((Entry) null).when(entryGroup1).createEntry();
      doReturn((Feature) null).when(entryGroup1).createFeature();
      doReturn((Entry) null, (Entry) null).when(entryGroup1).elementAt(anyInt());
      doReturn((ActionController) null, (ActionController) null).when(entryGroup1).getActionController();
      doReturn((EntryVector) null).when(entryGroup1).getActiveEntries();
      doReturn((Entry) null).when(entryGroup1).getSequenceEntry();
      doReturn(true).when(entryGroup1).hasUnsavedChanges();
      doReturn(963, 963).when(entryGroup1).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(false, false).when(entryGroup1).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, (FeaturePredicate) null, "");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("0v0uFAPl)Y.t'ZP+}", "zL([u;*").when(featureVector1).toString();
      doReturn(963).when(featureVector1).size();
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, featureVector1, "");
      filteredEntryGroup3.elementAt((-1084));
      filteredEntryGroup2.setIsActive((Entry) null, false);
      FeatureVector featureVector2 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("Q5QOo").when(featureVector2).toString();
      doReturn(963).when(featureVector2).indexOf(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup4 = new FilteredEntryGroup(filteredEntryGroup3, featureVector2, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      filteredEntryGroup4.getActionController();
      filteredEntryGroup2.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup3.getFeaturesInIndexRange(0, (-1));
      filteredEntryGroup3.getAllFeaturesCount();
      filteredEntryGroup3.ref();
      filteredEntryGroup2.addFeatureChangeListener((FeatureChangeListener) null);
      filteredEntryGroup2.getActionController();
      filteredEntryGroup2.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup3.hasUnsavedChanges();
      filteredEntryGroup2.createFeature();
      filteredEntryGroup4.indexOf((Feature) null);
      filteredEntryGroup3.getActiveEntries();
      filteredEntryGroup2.elementAt(963);
      filteredEntryGroup3.getSequenceEntry();
      filteredEntryGroup4.removeElement((Entry) null);
      filteredEntryGroup2.removeElement((Entry) null);
      filteredEntryGroup2.createEntry();
      filteredEntryGroup3.indexOf((Entry) null);
  }

  @Test(timeout = 4000)
  public void test06()  throws Throwable  {
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn(featureVector0).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn((-874), 0).when(entryGroup0).refCount();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector1, "");
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "\fF/8M8M");
      filteredEntryGroup1.getActionController();
      filteredEntryGroup1.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup1.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup1.refCount();
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.getFeaturesInRange(range0);
      filteredEntryGroup1.refCount();
  }

  @Test(timeout = 4000)
  public void test07()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn(true).when(entryGroup0).contains(any(uk.ac.sanger.artemis.Feature.class));
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn(0).when(entryGroup0).getSequenceLength();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0).when(entryGroup0).size();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn("uk.ac.sanger.artemis.FilteredEntryGroup").when(featurePredicate0).toString();
      doReturn(true).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "'JNz<AasY;\"d");
      filteredEntryGroup0.createFeature();
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "YF&wvn`");
      filteredEntryGroup1.size();
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryChanged(entryChangeEvent0);
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "HHd|35Q");
      filteredEntryGroup2.getActionController();
      filteredEntryGroup0.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup1.hasUnsavedChanges();
      filteredEntryGroup2.getSequenceLength();
      filteredEntryGroup0.contains((Feature) null);
      filteredEntryGroup1.createEntry(" |&UNpbuzB~$4`");
      filteredEntryGroup1.addElement((Entry) null);
      filteredEntryGroup1.addFeatureChangeListener((FeatureChangeListener) null);
      filteredEntryGroup2.setDefaultEntry((Entry) null);
  }

  @Test(timeout = 4000)
  public void test08()  throws Throwable  {
      
  }

  @Test(timeout = 4000)
  public void test09()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn(0).when(entryGroup0).getSequenceLength();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, ",aa:Sec)");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      FeatureChangeEvent featureChangeEvent0 = mock(FeatureChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.featureChanged(featureChangeEvent0);
      filteredEntryGroup0.getSequenceLength();
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryGroupChanged(entryGroupChangeEvent0);
  }

  @Test(timeout = 4000)
  public void test10()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("`.AH^4R", "<FjVKT`7L").when(featureVector0).toString();
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "o&rsh(NO&aRd.a*66[");
      filteredEntryGroup0.getAllFeatures();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(featurePredicate0).toString();
      doReturn(false, false, false, false, false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "o&rsh(NO&aRd.a*66[");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((Feature) null, (Feature) null, (Feature) null, (Feature) null, (Feature) null).when(featureVector1).elementAt(anyInt());
      doReturn(2384, 0, 0, 0, 0).when(featureVector1).size();
      filteredEntryGroup1.filterFeatures(featureVector1);
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup1.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test11()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("Ktlj2~=0>aNW L", "y", "Ktlj2~=0>aNW L", "y", "uk.ac.sanger.artemis.io.GFFDocumentEntry").when(entryGroup0).toString();
      doReturn((Bases) null).when(entryGroup0).getBases();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "}");
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featurePredicate0).toString();
      doReturn(false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((Feature) null).when(featureVector1).elementAt(anyInt());
      doReturn(1815, 0).when(featureVector1).size();
      FeatureVector featureVector2 = filteredEntryGroup1.filterFeatures(featureVector1);
      filteredEntryGroup1.filterFeatures(featureVector2);
      filteredEntryGroup0.getBases();
  }

  @Test(timeout = 4000)
  public void test12()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, "Could not understand the start or end base of a GFF feature: ", (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn(entryVector0, (EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn((Bases) null).when(entryGroup0).getBases();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0, 0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(0).when(entryGroup0).size();
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(featureVector0).toString();
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((-1056)).when(featureVector1).size();
      filteredEntryGroup0.filterFeatures(featureVector1);
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, "");
      filteredEntryGroup1.getAllFeatures();
      filteredEntryGroup0.createFeature();
      filteredEntryGroup1.indexOf((Feature) null);
      filteredEntryGroup1.setIsActive((Entry) null, true);
      filteredEntryGroup1.indexOf((Feature) null);
      filteredEntryGroup0.setDefaultEntry((Entry) null);
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.truncate(range0);
      filteredEntryGroup1.unref();
      filteredEntryGroup0.getBases();
      filteredEntryGroup1.setIsActive((Entry) null, true);
      filteredEntryGroup0.reverseComplement();
      filteredEntryGroup0.setIsActive(5, false);
      filteredEntryGroup1.hasUnsavedChanges();
      filteredEntryGroup0.unref();
      filteredEntryGroup0.addEntryChangeListener((EntryChangeListener) null);
      filteredEntryGroup1.size();
      filteredEntryGroup0.getAllFeatures();
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup0.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test13()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((-4192)).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Bases) null).when(entryGroup0).getBases();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn((Feature) null).when(featureVector0).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "v");
      filteredEntryGroup1.featureAt((-4192));
      filteredEntryGroup0.getBases();
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, "Could not understand the start or end base of a GFF feature: ", (String) null).when(entryGroup1).toString();
      doReturn((Feature) null).when(entryGroup1).createFeature();
      doReturn(entryVector0).when(entryGroup1).getActiveEntries();
      doReturn((Bases) null).when(entryGroup1).getBases();
      doReturn(true).when(entryGroup1).hasUnsavedChanges();
      doReturn(125).when(entryGroup1).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(39).when(entryGroup1).size();
      doReturn(filteredEntryGroup1).when(entryGroup1).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, featureVector1, "");
      FeatureVector featureVector2 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((-1056)).when(featureVector2).size();
      filteredEntryGroup2.filterFeatures(featureVector2);
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, (FeaturePredicate) null, "");
      filteredEntryGroup3.getAllFeatures();
      filteredEntryGroup2.createFeature();
      filteredEntryGroup3.indexOf((Feature) null);
      filteredEntryGroup3.setIsActive((Entry) null, true);
      filteredEntryGroup3.indexOf((Feature) null);
      filteredEntryGroup2.setDefaultEntry((Entry) null);
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup3.truncate(range0);
      filteredEntryGroup3.unref();
      filteredEntryGroup2.getBases();
      filteredEntryGroup2.reverseComplement();
      filteredEntryGroup2.setIsActive(5, false);
      filteredEntryGroup3.hasUnsavedChanges();
      filteredEntryGroup2.unref();
      filteredEntryGroup2.addEntryChangeListener((EntryChangeListener) null);
      filteredEntryGroup3.size();
  }

  @Test(timeout = 4000)
  public void test14()  throws Throwable  {
      Entry entry0 = mock(Entry.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(entry0).toString();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "C 5UXIYi", "C 5UXIYi", ";M_1tlTsuyl}26o").when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(entry0).when(entryGroup0).getSequenceEntry();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, ",wLuD");
      Entry entry1 = filteredEntryGroup0.getSequenceEntry();
      filteredEntryGroup0.addElement(entry1);
      filteredEntryGroup0.createFeature();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getFeaturesInRange((Range) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test15()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(0).when(entryGroup0).getSequenceLength();
      doReturn(0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      Feature feature0 = filteredEntryGroup1.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate1, "uk.ac.sanger.artemis.FilteredEntryGroup");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      filteredEntryGroup2.addFeatureChangeListener(filteredEntryGroup1);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      filteredEntryGroup2.unref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      ActionController actionController0 = filteredEntryGroup2.getActionController();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(actionController0);
      
      filteredEntryGroup1.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int0 = filteredEntryGroup1.getSequenceLength();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup2.elementAt(0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(entry0);
      
      filteredEntryGroup2.setIsActive((Entry) null, true);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      filteredEntryGroup0.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup2.filterFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test16()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null, (Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn((ActionController) null, (ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn((Entry) null).when(entryGroup0).getSequenceEntry();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(false).when(entryGroup0).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("Gly", "}@@:3'0(M").when(featureVector0).toString();
      doReturn((-1)).when(featureVector0).size();
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.elementAt((-1084));
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      filteredEntryGroup0.setIsActive((Entry) null, false);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("gY<S}").when(featureVector1).toString();
      doReturn((-1)).when(featureVector1).indexOf(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup1, featureVector1, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      ActionController actionController0 = filteredEntryGroup2.getActionController();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(actionController0);
      
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      
      FeatureVector featureVector2 = filteredEntryGroup1.getFeaturesInIndexRange(0, (-1));
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(featureVector2.equals((Object)featureVector1));
      assertFalse(featureVector2.equals((Object)featureVector0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(featureVector2);
      
      int int0 = filteredEntryGroup1.getAllFeaturesCount();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals((-1), int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.ref();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      
      ActionController actionController1 = filteredEntryGroup0.getActionController();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNull(actionController1);
      
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      
      boolean boolean0 = filteredEntryGroup1.hasUnsavedChanges();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNull(feature0);
      
      int int1 = filteredEntryGroup2.indexOf((Feature) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertTrue(int1 == int0);
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertEquals((-1), int1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      EntryVector entryVector1 = filteredEntryGroup1.getActiveEntries();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entryVector1);
      
      Entry entry1 = filteredEntryGroup0.elementAt((-1));
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNull(entry1);
      
      Entry entry2 = filteredEntryGroup1.getSequenceEntry();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry2);
      
      boolean boolean1 = filteredEntryGroup2.removeElement((Entry) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean1 == boolean0);
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(boolean1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test17()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((-1619)).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, "Could not understand the start or end base of a GFF feature: ", (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn(entryVector0).when(entryGroup0).getActiveEntries();
      doReturn((Bases) null).when(entryGroup0).getBases();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(0).when(entryGroup0).size();
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((-1056)).when(featureVector1).size();
      FeatureVector featureVector2 = filteredEntryGroup0.filterFeatures(featureVector1);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(featureVector2.equals((Object)featureVector0));
      assertFalse(featureVector2.equals((Object)featureVector1));
      assertNotNull(featureVector2);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeatureVector featureVector3 = filteredEntryGroup1.getAllFeatures();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(featureVector3.equals((Object)featureVector2));
      assertFalse(featureVector3.equals((Object)featureVector1));
      assertFalse(featureVector3.equals((Object)featureVector0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(featureVector3, featureVector2);
      assertNotNull(featureVector3);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      int int0 = filteredEntryGroup1.indexOf((Feature) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals((-1), int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.setIsActive((Entry) null, true);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int1 = filteredEntryGroup1.indexOf((Feature) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(int1 == int0);
      assertEquals((-1), int1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup1 = filteredEntryGroup1.truncate(range0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entryGroup1);
      
      filteredEntryGroup1.unref();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Bases bases0 = filteredEntryGroup0.getBases();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(bases0);
      
      filteredEntryGroup0.reverseComplement();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup0.setIsActive(5, false);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.hasUnsavedChanges();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.unref();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup0.addEntryChangeListener((EntryChangeListener) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      int int2 = filteredEntryGroup1.size();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(int2 == int0);
      assertFalse(int2 == int1);
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test18()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "*PMcA_EC");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("*PMcA_EC", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.elementAt(438);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("*PMcA_EC", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      EntryVector entryVector0 = filteredEntryGroup0.getActiveEntries();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entryVector0);
      
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("]t{:xZrHreGx)yuW%", "", "", "m/`ZP,T+=(]89Wxt", "]t{:xZrHreGx)yuW%").when(entryGroup1).toString();
      doReturn((Entry) null).when(entryGroup1).createEntry();
      doReturn((Feature) null).when(entryGroup1).createFeature();
      doReturn((Entry) null, (Entry) null).when(entryGroup1).elementAt(anyInt());
      doReturn((ActionController) null, (ActionController) null).when(entryGroup1).getActionController();
      doReturn((EntryVector) null).when(entryGroup1).getActiveEntries();
      doReturn((Entry) null).when(entryGroup1).getSequenceEntry();
      doReturn(true).when(entryGroup1).hasUnsavedChanges();
      doReturn(438, (-1745)).when(entryGroup1).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(true, false).when(entryGroup1).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, (FeaturePredicate) null, "");
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup2);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("", "*PMcA_EC").when(featureVector1).toString();
      doReturn(1).when(featureVector1).size();
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, featureVector1, "");
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup3);
      
      Entry entry1 = filteredEntryGroup3.elementAt((-1084));
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNull(entry1);
      
      filteredEntryGroup2.setIsActive((Entry) null, false);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      FeatureVector featureVector2 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("").when(featureVector2).toString();
      doReturn(438).when(featureVector2).indexOf(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup4 = new FilteredEntryGroup(filteredEntryGroup3, featureVector2, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup4.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup4.getFilterName());
      assertEquals(0, filteredEntryGroup4.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup4);
      
      ActionController actionController0 = filteredEntryGroup4.getActionController();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup4.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup4.getFilterName());
      assertEquals(0, filteredEntryGroup4.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup2.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      FeatureVector featureVector3 = filteredEntryGroup3.getFeaturesInIndexRange(0, (-1));
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(featureVector3.equals((Object)featureVector0));
      assertFalse(featureVector3.equals((Object)featureVector2));
      assertFalse(featureVector3.equals((Object)featureVector1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotNull(featureVector3);
      
      int int0 = filteredEntryGroup3.getAllFeaturesCount();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertEquals(1, int0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      
      filteredEntryGroup3.ref();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      
      filteredEntryGroup2.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      ActionController actionController1 = filteredEntryGroup2.getActionController();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(actionController1);
      
      filteredEntryGroup2.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup3.hasUnsavedChanges();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertTrue(boolean0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      
      Feature feature0 = filteredEntryGroup2.createFeature();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(feature0);
      
      int int1 = filteredEntryGroup4.indexOf((Feature) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup4.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup4.getFilterName());
      assertEquals(0, filteredEntryGroup4.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(int1 == int0);
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup1));
      assertEquals(438, int1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup1);
      
      EntryVector entryVector1 = filteredEntryGroup3.getActiveEntries();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNull(entryVector1);
      
      Entry entry2 = filteredEntryGroup2.elementAt(438);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(entry2);
      
      Entry entry3 = filteredEntryGroup3.getSequenceEntry();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNull(entry3);
      
      boolean boolean1 = filteredEntryGroup4.removeElement((Entry) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup4.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup4.getFilterName());
      assertEquals(0, filteredEntryGroup4.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertTrue(boolean1 == boolean0);
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup4.equals((Object)filteredEntryGroup1));
      assertTrue(boolean1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup4, filteredEntryGroup1);
      
      boolean boolean2 = filteredEntryGroup2.removeElement((Entry) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(boolean2 == boolean0);
      assertFalse(boolean2 == boolean1);
      assertFalse(boolean2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      Entry entry4 = filteredEntryGroup2.createEntry();
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(entry4);
      
      int int2 = filteredEntryGroup3.indexOf((Entry) null);
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(int2 == int0);
      assertFalse(int2 == int1);
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup4));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertEquals((-1745), int2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup4);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
  }

  @Test(timeout = 4000)
  public void test19()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn("").when(entryVector0).toString();
      doReturn((Entry) null).when(entryVector0).elementAt(anyInt());
      doReturn(101).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("r' z]0<.}CCKc1M", "", "#[U:", ",C-$bQWaVBL:8j2.>d", (String) null).when(entryGroup0).toString();
      doReturn(entryVector0).when(entryGroup0).getActiveEntries();
      doReturn(true).when(entryGroup0).isReadOnly();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      boolean boolean0 = filteredEntryGroup0.isReadOnly();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertTrue(boolean0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup1.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test20()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, ", ");
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, ", ");
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup1, featurePredicate1, ", ");
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(", ", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      int int0 = (-1645);
      filteredEntryGroup0.addFeatureChangeListener(filteredEntryGroup1);
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      
      Entry entry0 = filteredEntryGroup2.elementAt((-1645));
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(", ", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(entry0);
      
      filteredEntryGroup1.add((Entry) null);
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      
      boolean boolean0 = filteredEntryGroup2.isActive((Entry) null);
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(", ", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      filteredEntryGroup1.setDefaultEntry((Entry) null);
      assertEquals(", ", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(", ", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup0.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test21()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).getSequenceEntry();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, ",wLuD");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(",wLuD", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup0.getSequenceEntry();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(",wLuD", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(entry0);
      
      filteredEntryGroup0.addElement((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(",wLuD", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn((Feature) null).when(featureVector0).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(",wLuD", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.addFeatureChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(",wLuD", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getFeaturesInIndexRange((-1056), (-1056));
        fail("Expecting exception: Error");
      
      } catch(Error e) {
         //
         // internal error - adding a null object
         //
         verifyException("uk.ac.sanger.artemis.util.FastVector", e);
      }
  }

  @Test(timeout = 4000)
  public void test22()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(0).when(entryGroup0).getSequenceLength();
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.getSequenceLength();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup1.createEntry();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.isActive((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate1, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup2.entryChanged(entryChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      ActionController actionController0 = filteredEntryGroup2.getActionController();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(actionController0);
      
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup0.reverseComplement();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getFeaturesInRange(range0);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test23()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((Entry) null).when(entryVector0).elementAt(anyInt());
      doReturn(1500).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Feature feature0 = filteredEntryGroup1.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, "Could not understand the start or end base of a GFF feature: ", (String) null).when(entryGroup1).toString();
      doReturn(entryVector0).when(entryGroup1).getActiveEntries();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, featureVector1, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(1500, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup2);
      
      FeatureVector featureVector2 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((-1056)).when(featureVector2).size();
      FeatureVector featureVector3 = filteredEntryGroup2.filterFeatures(featureVector2);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(1500, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(featureVector3.equals((Object)featureVector2));
      assertFalse(featureVector3.equals((Object)featureVector1));
      assertFalse(featureVector3.equals((Object)featureVector0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotNull(featureVector3);
      
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, (FeaturePredicate) null, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(1500, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals("", filteredEntryGroup3.getFilterName());
      assertEquals(1500, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup3);
      
      Entry entry0 = null;
      // Undeclared exception!
      try { 
        filteredEntryGroup3.getAllFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test24()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("(&<`#7u'm", "(&<`#7u'm", (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn(true).when(entryGroup0).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.removeElement((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test25()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup1).toString();
      doReturn((Feature) null).when(entryGroup1).createFeature();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup1, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, (String) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Feature feature0 = filteredEntryGroup1.createFeature();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("Xyvzq-").when(featureVector1).toString();
      doReturn((Feature) null).when(featureVector1).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup0, featureVector1, "LItR''lM v^d");
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("LItR''lM v^d", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn("").when(featurePredicate1).toString();
      doReturn(true).when(featurePredicate1).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, featurePredicate1, "\fF/8M8M");
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("LItR''lM v^d", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("\fF/8M8M", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup3);
      
      ActionController actionController0 = filteredEntryGroup3.getActionController();
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("LItR''lM v^d", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("\fF/8M8M", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup3.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("LItR''lM v^d", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("\fF/8M8M", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      
      filteredEntryGroup3.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("LItR''lM v^d", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("\fF/8M8M", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      
      Feature feature1 = filteredEntryGroup2.featureAt(833);
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("LItR''lM v^d", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(feature1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup3.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test26()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null, (Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null, (Entry) null).when(entryGroup0).getSequenceEntry();
      doReturn(false).when(entryGroup0).isReadOnly();
      doReturn(false, false, false).when(entryGroup0).remove(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "7<jj$$g");
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null).when(featureVector0).toString();
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "7<jj$$g");
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup0.createEntry("7<jj$$g");
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.remove((Entry) null);
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FeatureVector featureVector1 = filteredEntryGroup1.getAllFeatures();
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertSame(featureVector1, featureVector0);
      assertNotNull(featureVector1);
      
      boolean boolean1 = filteredEntryGroup1.remove((Entry) null);
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean1 == boolean0);
      assertFalse(boolean1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup1, featureVector1, "");
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup2);
      
      Entry entry1 = filteredEntryGroup2.getSequenceEntry();
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(entry1);
      
      boolean boolean2 = filteredEntryGroup1.remove((Entry) null);
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertTrue(boolean2 == boolean0);
      assertTrue(boolean2 == boolean1);
      assertFalse(boolean2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup2.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      boolean boolean3 = filteredEntryGroup1.isReadOnly();
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertTrue(boolean3 == boolean0);
      assertTrue(boolean3 == boolean2);
      assertTrue(boolean3 == boolean1);
      assertFalse(boolean3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      
      String string0 = filteredEntryGroup0.getFilterName();
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertEquals("7<jj$$g", string0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotNull(string0);
      
      filteredEntryGroup2.add((Entry) null);
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup0, featureVector1, "b+)*FQg=x3z");
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("b+)*FQg=x3z", filteredEntryGroup3.getFilterName());
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotNull(filteredEntryGroup3);
      
      Feature feature0 = filteredEntryGroup3.createFeature();
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("b+)*FQg=x3z", filteredEntryGroup3.getFilterName());
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertNull(feature0);
      
      filteredEntryGroup3.setIsActive(5, false);
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("b+)*FQg=x3z", filteredEntryGroup3.getFilterName());
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      
      filteredEntryGroup0.removeEntryChangeListener((EntryChangeListener) null);
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      FeatureVector featureVector2 = filteredEntryGroup3.getAllFeatures();
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("b+)*FQg=x3z", filteredEntryGroup3.getFilterName());
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector2, featureVector0);
      assertSame(featureVector2, featureVector1);
      assertSame(featureVector1, featureVector0);
      assertSame(featureVector1, featureVector2);
      assertNotNull(featureVector2);
      
      filteredEntryGroup2.unref();
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertSame(featureVector1, featureVector2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      Entry entry2 = filteredEntryGroup2.getSequenceEntry();
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertSame(featureVector1, featureVector2);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(entry2);
      
      filteredEntryGroup3.add((Entry) null);
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals("b+)*FQg=x3z", filteredEntryGroup3.getFilterName());
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertSame(featureVector1, featureVector0);
      assertSame(featureVector1, featureVector2);
      
      Entry entry3 = filteredEntryGroup1.createEntry("uk.ac.sanger.artemis.FilteredEntryGroup$2");
      assertEquals("7<jj$$g", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("7<jj$$g", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNull(entry3);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup2.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test27()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(0).when(entryGroup0).getSequenceLength();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0).when(entryGroup0).size();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featurePredicate0).toString();
      doReturn(false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "'JNz<AasY;\"d");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertNull(feature0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "YF&wvn`");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.size();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryChanged(entryChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "HHd|35Q");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("HHd|35Q", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup2);
      
      ActionController actionController0 = filteredEntryGroup2.getActionController();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("HHd|35Q", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup0.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.hasUnsavedChanges();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int1 = filteredEntryGroup2.getSequenceLength();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("HHd|35Q", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertTrue(int1 == int0);
      assertEquals(0, int1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      boolean boolean1 = filteredEntryGroup0.contains((Feature) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertTrue(boolean1 == boolean0);
      assertFalse(boolean1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry(" |&UNpbuzB~$4`");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      filteredEntryGroup1.addElement((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals("YF&wvn`", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup2.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("'JNz<AasY;\"d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("HHd|35Q", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.featureAt(3);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test28()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "", "b", "").when(entryGroup0).toString();
      doReturn(entryVector0).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeatureVector featureVector1 = filteredEntryGroup1.filterFeatures();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$3", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(featureVector1.equals((Object)featureVector0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(featureVector1);
  }

  @Test(timeout = 4000)
  public void test29()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((EntryVector) null, (EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn((Feature) null).when(featureVector0).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "-N_jn8,I.f0[GZ~5Zd");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      EntryVector entryVector0 = filteredEntryGroup0.getActiveEntries();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertNull(entryVector0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featurePredicate0).toString();
      doReturn(false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "-N_jn8,I.f0[GZ~5Zd");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      EntryVector entryVector1 = filteredEntryGroup1.getActiveEntries();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entryVector1);
      
      filteredEntryGroup1.removeFeatureChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      boolean boolean0 = filteredEntryGroup1.contains((Feature) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("-N_jn8,I.f0[GZ~5Zd", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getFeaturesInIndexRange(1040, 1040);
        fail("Expecting exception: Error");
      
      } catch(Error e) {
         //
         // internal error - adding a null object
         //
         verifyException("uk.ac.sanger.artemis.util.FastVector", e);
      }
  }

  @Test(timeout = 4000)
  public void test30()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn(0).when(entryGroup0).refCount();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "QK3v4");
      assertEquals("QK3v4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals("QK3v4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry();
      assertEquals("QK3v4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "QK3v4", "QK3v4", "", "").when(entryGroup1).toString();
      doReturn((Entry) null).when(entryGroup1).createEntry();
      doReturn((Entry) null, (Entry) null).when(entryGroup1).getSequenceEntry();
      doReturn((-1)).when(entryGroup1).getSequenceLength();
      doReturn(true).when(entryGroup1).isActive(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(true).when(entryGroup1).isReadOnly();
      doReturn((-1)).when(entryGroup1).size();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, featureVector1, "FQ\"H,EY");
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      FeatureChangeEvent featureChangeEvent0 = mock(FeatureChangeEvent.class, new ViolatedAssumptionAnswer());
      Entry entry1 = filteredEntryGroup2.getSequenceEntry();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(entry1);
      
      filteredEntryGroup2.add((Entry) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      filteredEntryGroup2.featureChanged(featureChangeEvent0);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup2.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, (FeaturePredicate) null, "FQ\"H,EY");
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup3);
      
      Entry entry2 = filteredEntryGroup2.getSequenceEntry();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(entry2);
      
      filteredEntryGroup3.add((Entry) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      
      filteredEntryGroup3.reverseComplement();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      
      int int0 = filteredEntryGroup2.getSequenceLength();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertEquals((-1), int0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      filteredEntryGroup3.addElement((Entry) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      
      filteredEntryGroup2.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      filteredEntryGroup2.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      boolean boolean0 = filteredEntryGroup2.isActive((Entry) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertTrue(boolean0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup3.entryChanged(entryChangeEvent0);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      
      int int1 = filteredEntryGroup3.size();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertTrue(int1 == int0);
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertEquals((-1), int1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      
      boolean boolean1 = filteredEntryGroup2.isReadOnly();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertTrue(boolean1 == boolean0);
      assertTrue(boolean1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      Entry entry3 = filteredEntryGroup3.createEntry();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertEquals("FQ\"H,EY", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals((-1), filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNull(entry3);
      
      filteredEntryGroup2.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals("FQ\"H,EY", filteredEntryGroup2.getFilterName());
      assertEquals((-1), filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      int int2 = filteredEntryGroup0.refCount();
      assertEquals("QK3v4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(int2 == int1);
      assertFalse(int2 == int0);
      assertEquals(0, int2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
  }

  @Test(timeout = 4000)
  public void test31()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(entryVector0).toString();
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("uk.ac.sanger.artemis.FilteredEntryGroup", "1_O!1w+4", "`6uh$GzN\"/V~J:0", "D-fBu$%JA,$", "`6uh$GzN\"/V~J:0").when(entryGroup0).toString();
      doReturn(entryVector0, (EntryVector) null).when(entryGroup0).getActiveEntries();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "<M8`)Xz>~:$>0k`LzI");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "<M8`)Xz>~:$>0k`LzI");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeatureEnumeration featureEnumeration0 = filteredEntryGroup1.features();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(featureEnumeration0);
      
      filteredEntryGroup1.unref();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("<M8`)Xz>~:$>0k`LzI", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup1.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test32()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, (String) null);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "1]");
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("1]", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      ActionController actionController0 = filteredEntryGroup1.getActionController();
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("1]", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(actionController0);
      
      filteredEntryGroup0.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
  }

  @Test(timeout = 4000)
  public void test33()  throws Throwable  {
      Entry entry0 = null;
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "", "", "").when(entryGroup0).toString();
      doReturn(true).when(entryGroup0).hasUnsavedChanges();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      String string0 = "z";
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "z");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("z", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "z");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("z", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("z", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.hasUnsavedChanges();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("z", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("z", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((Feature) null).when(featureVector1).elementAt(anyInt());
      doReturn(1).when(featureVector1).size();
      // Undeclared exception!
      try { 
        filteredEntryGroup0.filterFeatures(featureVector1);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test34()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      doReturn(0, 0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      String string0 = null;
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, (String) null);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, (String) null);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.setIsActive((Entry) null, true);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup1.createEntry();
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      int int0 = filteredEntryGroup1.indexOf((Entry) null);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry1 = filteredEntryGroup1.getDefaultEntry();
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry1);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup1 = filteredEntryGroup0.truncate(range0);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entryGroup1);
      
      ActionController actionController0 = filteredEntryGroup0.getActionController();
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup1.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup1.createFeature();
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test35()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      doReturn(false).when(entryGroup0).isReadOnly();
      doReturn(false).when(entryGroup0).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.reverseComplement();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.ref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.ref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.getDefaultEntry();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup0.ref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup1.reverseComplement();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.removeElement((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.entryChanged(entryChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      String string0 = filteredEntryGroup1.getFilterName();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals("", string0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(string0);
      
      boolean boolean1 = filteredEntryGroup1.isReadOnly();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertTrue(boolean1 == boolean0);
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test36()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(entryVector0).toString();
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("mo!$>TPLf}x`ejqHx", "r0.{'#UE(!", "mo!$>TPLf}x`ejqHx", "", "uk.ac.sanger.artemis.FilteredEntryGroup$2").when(entryGroup0).toString();
      doReturn(entryVector0).when(entryGroup0).getActiveEntries();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "ENPp|y$p>");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn((Feature) null).when(featureVector0).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup1, featurePredicate1, "jslTG0T");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("jslTG0T", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotNull(filteredEntryGroup2);
      
      filteredEntryGroup0.addEntryChangeListener(filteredEntryGroup2);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("jslTG0T", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup0, featureVector1, "ENPp|y$p>");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals("ENPp|y$p>", filteredEntryGroup3.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertNotNull(filteredEntryGroup3);
      
      FeatureEnumeration featureEnumeration0 = filteredEntryGroup3.features();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup3.size());
      assertEquals("ENPp|y$p>", filteredEntryGroup3.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      assertNotNull(featureEnumeration0);
      
      Feature feature0 = filteredEntryGroup1.featureAt(0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ENPp|y$p>", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup3.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test37()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      doReturn(0).when(entryGroup0).getSequenceLength();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "d{>F(/3=FBk2)6.");
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      int int0 = filteredEntryGroup0.getSequenceLength();
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, int0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      String string0 = filteredEntryGroup1.getFilterName();
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals("", string0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(string0);
      
      Entry entry0 = filteredEntryGroup1.getDefaultEntry();
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      Feature feature0 = filteredEntryGroup1.createFeature();
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      Entry entry1 = filteredEntryGroup0.createEntry("d{>F(/3=FBk2)6.");
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry1);
      
      filteredEntryGroup1.addElement((Entry) null);
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.removeFeatureChangeListener((FeatureChangeListener) null);
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup1.reverseComplement();
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.removeEntryChangeListener(filteredEntryGroup1);
      assertEquals("d{>F(/3=FBk2)6.", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test38()  throws Throwable  {
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "noprivate", "", "uk.ac.sanger.artemis.FeatureSegmentVector", "start position is greater than end position: ").when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(featureVector0).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(true).when(entryGroup0).remove(any(uk.ac.sanger.artemis.Entry.class));
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector1, "[");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "p,$O$");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("p,$O$", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = null;
      boolean boolean0 = filteredEntryGroup1.remove((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("p,$O$", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("p,$O$", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.addFeatureChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("p,$O$", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FeatureVector featureVector2 = filteredEntryGroup0.getFeaturesInRange((Range) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(featureVector2.equals((Object)featureVector0));
      assertFalse(featureVector2.equals((Object)featureVector1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotNull(featureVector2);
      
      EntryGroup entryGroup1 = filteredEntryGroup1.truncate((Range) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("[", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("p,$O$", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getAllFeaturesCount();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test39()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "unexpected characters in location");
      assertEquals("unexpected characters in location", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      EntryGroupChangeListener entryGroupChangeListener0 = null;
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("unexpected characters in location", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals("unexpected characters in location", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(feature0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test40()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(entryVector0).toString();
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("r' z]0<.}CCKc1M", "", "#[U:", ",C-$bQWaVBL:8j2.>d", (String) null).when(entryGroup0).toString();
      doReturn(entryVector0).when(entryGroup0).getActiveEntries();
      doReturn(true).when(entryGroup0).isReadOnly();
      doReturn(0).when(entryGroup0).size();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      boolean boolean0 = filteredEntryGroup0.isReadOnly();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertTrue(boolean0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup1.new FeatureEnumerator();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup_FeatureEnumerator0);
      
      int int0 = filteredEntryGroup0.size();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
  }

  @Test(timeout = 4000)
  public void test41()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null, (Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "#`b}\"?Rnb.bmCI+");
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featurePredicate0).toString();
      doReturn(false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, ":D%(1");
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(":D%(1", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.removeFeatureChangeListener(filteredEntryGroup0);
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(":D%(1", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup0.createEntry("m0#bb%<*H}1");
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.isActive((Entry) null);
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(":D%(1", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry1 = filteredEntryGroup0.createEntry("m0#bb%<*H}1");
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry1);
      
      filteredEntryGroup0.addElement((Entry) null);
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup1.ref();
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(":D%(1", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int0 = (-2444);
      int int1 = (-863);
      boolean boolean1 = filteredEntryGroup1.contains((Feature) null);
      assertEquals("#`b}\"?Rnb.bmCI+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(":D%(1", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean1 == boolean0);
      assertFalse(boolean1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.filterFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test42()  throws Throwable  {
      ActionController actionController0 = mock(ActionController.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(actionController0).toString();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "", "uk.ac.sanger.artemis.FilteredEntryGroup$3", "uk.ac.sanger.artemis.FilteredEntryGroup$3").when(entryGroup0).toString();
      doReturn(actionController0).when(entryGroup0).getActionController();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "LItR''lM v^d");
      assertEquals("LItR''lM v^d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      ActionController actionController1 = filteredEntryGroup0.getActionController();
      assertEquals("LItR''lM v^d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertSame(actionController1, actionController0);
      assertNotNull(actionController1);
      
      filteredEntryGroup0.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("LItR''lM v^d", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
  }

  @Test(timeout = 4000)
  public void test43()  throws Throwable  {
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("uk.ac.sanger.artemis.FilteredEntryGroup$1", "artemis", "uk.ac.sanger.artemis.FilteredEntryGroup$1", "artemis", "uk.ac.sanger.artemis.FilteredEntryGroup$1").when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(featureVector0).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn("uk.ac.sanger.artemis.FilteredEntryGroup$1").when(featureVector1).toString();
      doReturn((Feature) null).when(featureVector1).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector1, "complement");
      assertEquals("complement", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "complement");
      assertEquals("complement", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("complement", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      Feature feature0 = filteredEntryGroup0.featureAt((-1778));
      assertEquals("complement", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      FeatureVector featureVector2 = filteredEntryGroup1.getFeaturesInRange(range0);
      assertEquals("complement", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("complement", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(featureVector2.equals((Object)featureVector1));
      assertFalse(featureVector2.equals((Object)featureVector0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(featureVector2);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.featureAt(3628);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test44()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      String string0 = "Lvj)E1PK0|uF:";
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.entryChanged(entryChangeEvent0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getFeaturesInIndexRange(0, 0);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test45()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).getSequenceEntry();
      doReturn(0, 0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(0).when(entryGroup0).refCount();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn((Feature) null).when(featureVector0).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "7\"lU$C3jc2YO WZA");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup0.getSequenceEntry();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertNull(entry0);
      
      Feature feature0 = filteredEntryGroup0.featureAt(1373);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertNull(feature0);
      
      filteredEntryGroup0.addEntryChangeListener((EntryChangeListener) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      
      filteredEntryGroup0.setIsActive((Entry) null, true);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, "}G'%B?b");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("}G'%B?b", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.isActive((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("}G'%B?b", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int0 = filteredEntryGroup0.indexOf((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      String string0 = filteredEntryGroup0.getFilterName();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertEquals("7\"lU$C3jc2YO WZA", string0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotNull(string0);
      
      int int1 = filteredEntryGroup0.refCount();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("7\"lU$C3jc2YO WZA", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertTrue(int1 == int0);
      assertEquals(0, int1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
  }

  @Test(timeout = 4000)
  public void test46()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(entryGroup0).toString();
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("i)^t/(D9O", "i)^t/(D9O", "i)^t/(D9O", "", "").when(entryGroup1).toString();
      doReturn((-3427)).when(entryGroup1).getSequenceLength();
      doReturn(entryGroup0).when(entryGroup1).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup1, featurePredicate0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      int int0 = filteredEntryGroup0.getSequenceLength();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals((-3427), int0);
      
      filteredEntryGroup0.reverseComplement();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup2 = filteredEntryGroup0.truncate(range0);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, entryGroup2.refCount());
      assertEquals(0, entryGroup2.size());
      assertFalse(entryGroup2.equals((Object)entryGroup1));
      assertSame(entryGroup2, entryGroup0);
      assertNotSame(entryGroup2, entryGroup1);
      assertNotNull(entryGroup2);
  }

  @Test(timeout = 4000)
  public void test47()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("{", "{", (String) null, "uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", "uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator").when(entryGroup0).toString();
      doReturn(41).when(entryGroup0).refCount();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "-1armc");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(41, filteredEntryGroup0.refCount());
      assertEquals("-1armc", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "-1armc");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(41, filteredEntryGroup0.refCount());
      assertEquals("-1armc", filteredEntryGroup0.getFilterName());
      assertEquals(41, filteredEntryGroup1.refCount());
      assertEquals("-1armc", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.refCount();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(41, filteredEntryGroup0.refCount());
      assertEquals("-1armc", filteredEntryGroup0.getFilterName());
      assertEquals(41, filteredEntryGroup1.refCount());
      assertEquals("-1armc", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(41, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test48()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("B=", "label", "0T~4o", "0T~4o", (String) null).when(entryGroup0).toString();
      doReturn(335).when(entryGroup0).getSequenceLength();
      doReturn(335, 0).when(entryGroup0).size();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "4['%g.GkYB+");
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      filteredEntryGroup0.unref();
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "4['%g.GkYB+");
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertEquals(335, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("4['%g.GkYB+", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.unref();
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertEquals(335, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("4['%g.GkYB+", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int0 = filteredEntryGroup1.size();
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertEquals(335, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("4['%g.GkYB+", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(335, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int1 = filteredEntryGroup1.getSequenceLength();
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertEquals(335, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("4['%g.GkYB+", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(int1 == int0);
      assertEquals(335, int1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryChanged(entryChangeEvent0);
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertEquals(335, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("4['%g.GkYB+", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      int int2 = filteredEntryGroup1.size();
      assertEquals("4['%g.GkYB+", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(335, filteredEntryGroup0.size());
      assertEquals(335, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("4['%g.GkYB+", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(int2 == int0);
      assertTrue(int2 == int1);
      assertEquals(335, int2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test49()  throws Throwable  {
      Bases bases0 = mock(Bases.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(bases0).toString();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("XQ7oZ\"EMazE", "}9a>O9xcOc", "#Mu+?%T2ip4Ld ALEfF", "#Mu+?%T2ip4Ld ALEfF", "range cannot start with: ").when(entryGroup0).toString();
      doReturn(bases0).when(entryGroup0).getBases();
      doReturn(1186).when(entryGroup0).size();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(1186, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(1186, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(1186, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.size();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(1186, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(1186, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(1186, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Bases bases1 = filteredEntryGroup0.getBases();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(1186, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, bases1.getTCount());
      assertEquals(0, bases1.getCCount());
      assertEquals(0, bases1.getGCount());
      assertEquals(0, bases1.getACount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertEquals((-5), Bases.MIN_PRIORITY);
      assertEquals(0, Bases.MEDIUM_PRIORITY);
      assertEquals(1, Bases.FORWARD);
      assertEquals(5, Bases.MAX_PRIORITY);
      assertEquals(2, Bases.REVERSE);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertSame(bases1, bases0);
      assertNotNull(bases1);
  }

  @Test(timeout = 4000)
  public void test50()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "#8zr5tXgY&_?,", "", "", "").when(entryGroup0).toString();
      doReturn(true).when(entryGroup0).isReadOnly();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "@=ig:7=4");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("@=ig:7=4", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("@=ig:7=4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.isReadOnly();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("@=ig:7=4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test51()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null, (Feature) null).when(entryGroup0).createFeature();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn((Entry) null).when(entryGroup0).getSequenceEntry();
      doReturn(0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(false).when(entryGroup0).isReadOnly();
      doReturn(false).when(entryGroup0).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "expected a range or a functional");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.removeEntryChangeListener(filteredEntryGroup0);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup0.getSequenceEntry();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.removeElement((Entry) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.removeFeatureChangeListener((FeatureChangeListener) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.indexOf((Entry) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      boolean boolean1 = filteredEntryGroup1.isReadOnly();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertTrue(boolean1 == boolean0);
      assertFalse(boolean1);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup1.createFeature();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
      
      filteredEntryGroup0.ref();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      Feature feature1 = filteredEntryGroup0.createFeature();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature1);
      
      filteredEntryGroup1.removeFeatureChangeListener((FeatureChangeListener) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("expected a range or a functional", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      ActionController actionController0 = filteredEntryGroup0.getActionController();
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.features();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test52()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.filterFeatures((FeatureVector) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test53()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((Feature) null, (Feature) null).when(entryGroup0).createFeature();
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((Bases) null).when(entryGroup0).getBases();
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featurePredicate0).toString();
      doReturn(false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, (String) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.ref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, (String) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      ActionController actionController0 = filteredEntryGroup0.getActionController();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup1.removeEntryChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup1.createEntry((String) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup1 = filteredEntryGroup1.truncate(range0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entryGroup1);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      boolean boolean0 = filteredEntryGroup0.contains((Feature) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      String string0 = filteredEntryGroup1.getFilterName();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(string0);
      
      Bases bases0 = filteredEntryGroup1.getBases();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(bases0);
      
      Feature feature1 = filteredEntryGroup1.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.featureAt(2);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test54()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "uk.ac.sanger.artemis.io.SimpleDocumentEntry");
      assertEquals("uk.ac.sanger.artemis.io.SimpleDocumentEntry", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "uk.ac.sanger.artemis.io.SimpleDocumentEntry");
      assertEquals("uk.ac.sanger.artemis.io.SimpleDocumentEntry", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.io.SimpleDocumentEntry", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getAllFeaturesCount();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test55()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "ap0r1a>nxl3u");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      Entry entry0 = filteredEntryGroup0.getDefaultEntry();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNull(entry0);
      
      filteredEntryGroup0.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector1).size();
      FeatureVector featureVector2 = filteredEntryGroup0.filterFeatures(featureVector1);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(featureVector2.equals((Object)featureVector1));
      assertFalse(featureVector2.equals((Object)featureVector0));
      assertNotNull(featureVector2);
      
      filteredEntryGroup0.setIsActive(0, false);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "ap0r1a>nxl3u");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.ref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FeatureChangeEvent featureChangeEvent0 = mock(FeatureChangeEvent.class, new ViolatedAssumptionAnswer());
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("ap0r1a>nxl3u", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.contains((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test56()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null, (EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn((Entry) null).when(entryGroup0).getSequenceEntry();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "8i");
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = null;
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "8i");
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("8i", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry("");
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("8i", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      ActionController actionController0 = filteredEntryGroup0.getActionController();
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(actionController0);
      
      filteredEntryGroup1.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("8i", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Entry entry1 = filteredEntryGroup1.getSequenceEntry();
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("8i", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry1);
      
      filteredEntryGroup0.addFeatureChangeListener((FeatureChangeListener) null);
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(featureVector1).toString();
      doReturn((Feature) null).when(featureVector1).elementAt(anyInt());
      doReturn(0).when(featureVector1).size();
      EntryVector entryVector0 = filteredEntryGroup0.getActiveEntries();
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entryVector0);
      
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, featureVector1, "uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator");
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      EntryVector entryVector1 = filteredEntryGroup2.getActiveEntries();
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(entryVector1);
      
      int int0 = filteredEntryGroup2.getAllFeaturesCount();
      assertEquals("8i", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", filteredEntryGroup2.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup2));
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup2);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup2.getFeaturesInIndexRange((-1946), 1);
        fail("Expecting exception: Error");
      
      } catch(Error e) {
         //
         // internal error - adding a null object
         //
         verifyException("uk.ac.sanger.artemis.util.FastVector", e);
      }
  }

  @Test(timeout = 4000)
  public void test57()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "c/,=KM|#QK$");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("c/,=KM|#QK$", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      ActionController actionController0 = filteredEntryGroup0.getActionController();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("c/,=KM|#QK$", filteredEntryGroup0.getFilterName());
      assertNull(actionController0);
      
      filteredEntryGroup0.removeEntryChangeListener((EntryChangeListener) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("c/,=KM|#QK$", filteredEntryGroup0.getFilterName());
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeatureVector) null, "HE:");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("c/,=KM|#QK$", filteredEntryGroup0.getFilterName());
      assertEquals("HE:", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.addFeatureChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("c/,=KM|#QK$", filteredEntryGroup0.getFilterName());
      assertEquals("HE:", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.featureAt(2052);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test58()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "rS6X#/K!|3D$S)f!WX");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("rS6X#/K!|3D$S)f!WX", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("rS6X#/K!|3D$S)f!WX", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.unref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("rS6X#/K!|3D$S)f!WX", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.removeFeatureChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("rS6X#/K!|3D$S)f!WX", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.unref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("rS6X#/K!|3D$S)f!WX", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.features();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test59()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn(0).when(entryGroup0).refCount();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "-1armc");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("-1armc", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "-1armc");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("-1armc", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("-1armc", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.refCount();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("-1armc", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("-1armc", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test60()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      doReturn(false).when(entryGroup0).remove(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "`E_I\"PvuEBz");
      assertEquals("`E_I\"PvuEBz", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn(0).when(featureVector0).indexOf(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "**n(?F2T})`T8M");
      assertEquals("`E_I\"PvuEBz", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("**n(?F2T})`T8M", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry();
      assertEquals("`E_I\"PvuEBz", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("**n(?F2T})`T8M", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.remove((Entry) null);
      assertEquals("`E_I\"PvuEBz", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("**n(?F2T})`T8M", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Feature feature0 = filteredEntryGroup0.createFeature();
      assertEquals("`E_I\"PvuEBz", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(feature0);
      
      int int0 = filteredEntryGroup1.indexOf((Feature) null);
      assertEquals("`E_I\"PvuEBz", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("**n(?F2T})`T8M", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup0.indexOf((Feature) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test61()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(0).when(entryGroup0).getSequenceLength();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "CONTIG");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("CONTIG", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("CONTIG", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.getSequenceLength();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("CONTIG", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      String string0 = filteredEntryGroup1.getFilterName();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("CONTIG", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals("", string0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(string0);
      
      Entry entry0 = filteredEntryGroup1.createEntry();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("CONTIG", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("CONTIG", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getAllFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test62()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "=J*^8%@CmX+)V");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("=J*^8%@CmX+)V", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "note");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("=J*^8%@CmX+)V", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("note", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.filterFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test63()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(false).when(entryGroup0).remove(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "A2(4!d[)r\"A>v");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("A2(4!d[)r\"A>v", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      Entry entry0 = filteredEntryGroup0.createEntry((String) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("A2(4!d[)r\"A>v", filteredEntryGroup0.getFilterName());
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup0.remove((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("A2(4!d[)r\"A>v", filteredEntryGroup0.getFilterName());
      assertFalse(boolean0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, "codon_start");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("A2(4!d[)r\"A>v", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("codon_start", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.featureAt((-1133));
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test64()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.ref();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector1).size();
      FeatureVector featureVector2 = filteredEntryGroup1.filterFeatures(featureVector1);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(featureVector2.equals((Object)featureVector0));
      assertFalse(featureVector2.equals((Object)featureVector1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(featureVector2);
  }

  @Test(timeout = 4000)
  public void test65()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "uie#bO0O");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uie#bO0O", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "uie#bO0O");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uie#bO0O", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("uie#bO0O", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      String string0 = filteredEntryGroup1.getFilterName();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uie#bO0O", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("uie#bO0O", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals("uie#bO0O", string0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNotNull(string0);
  }

  @Test(timeout = 4000)
  public void test66()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn(false).when(entryGroup0).remove(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.elementAt(586);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.remove((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test67()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, (String) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector0).toString();
      doReturn((Feature) null).when(featureVector0).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, (String) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Feature feature0 = filteredEntryGroup1.featureAt((-407));
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertNull(filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(feature0);
  }

  @Test(timeout = 4000)
  public void test68()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      doReturn(false).when(entryGroup0).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(featureVector0).toString();
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "[q");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "uk.ac.sanger.artemis.FilteredEntryGroup");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup0.getDefaultEntry();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry0);
      
      boolean boolean0 = filteredEntryGroup1.removeElement((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.ref();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      FeatureVector featureVector1 = filteredEntryGroup0.getAllFeatures();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertSame(featureVector1, featureVector0);
      assertNotNull(featureVector1);
      
      Entry entry1 = filteredEntryGroup0.createEntry();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("[q", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(entry1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getFeaturesInIndexRange(0, 0);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test69()  throws Throwable  {
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = null;
      try {
        filteredEntryGroup0 = new FilteredEntryGroup((EntryGroup) null, featurePredicate0, "uk.ac.sanger.artemis.io.GFFDocumentEntry");
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test70()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Bases) null).when(entryGroup0).getBases();
      doReturn(0).when(entryGroup0).size();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      int int0 = filteredEntryGroup1.size();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      Bases bases0 = filteredEntryGroup0.getBases();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNull(bases0);
  }

  @Test(timeout = 4000)
  public void test71()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      filteredEntryGroup1.setIsActive(0, false);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test72()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(false).when(entryGroup0).isReadOnly();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "qs:ZF]1?f*< D");
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      boolean boolean0 = filteredEntryGroup0.isReadOnly();
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(boolean0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry();
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.addEntryChangeListener(filteredEntryGroup0);
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.entryChanged(entryChangeEvent0);
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup0.addElement((Entry) null);
      assertEquals("qs:ZF]1?f*< D", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getFeaturesInRange(range0);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test73()  throws Throwable  {
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = null;
      try {
        filteredEntryGroup0 = new FilteredEntryGroup((EntryGroup) null, featureVector0, "forward");
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test74()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "uk.ac.sanger.artemis.util.ReadOnlyException");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.util.ReadOnlyException", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "uk.ac.sanger.artemis.util.ReadOnlyException");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.util.ReadOnlyException", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.util.ReadOnlyException", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getAllFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test75()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, (String) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup1.addEntryGroupChangeListener((EntryGroupChangeListener) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.unref();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      FeatureChangeEvent featureChangeEvent0 = mock(FeatureChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.featureChanged(featureChangeEvent0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNull(filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
  }

  @Test(timeout = 4000)
  public void test76()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Bases) null).when(entryGroup0).getBases();
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "uk.ac.sanger.artemis.FilteredEntryGroup");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      Entry entry0 = filteredEntryGroup0.getDefaultEntry();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup0.getFilterName());
      assertNull(entry0);
      
      filteredEntryGroup0.add((Entry) null);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup0.getFilterName());
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "uk.ac.sanger.artemis.FilteredEntryGroup");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Bases bases0 = filteredEntryGroup1.getBases();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(bases0);
      
      filteredEntryGroup1.unref();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("uk.ac.sanger.artemis.FilteredEntryGroup", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test77()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeatureVector) null, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, ">b+W{?$BWK:e");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(">b+W{?$BWK:e", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      EntryGroup entryGroup1 = filteredEntryGroup1.truncate(range0);
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(">b+W{?$BWK:e", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entryGroup1);
  }

  @Test(timeout = 4000)
  public void test78()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn(false).when(entryGroup0).isReadOnly();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "@=ig:7=4");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("@=ig:7=4", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "");
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("@=ig:7=4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      boolean boolean0 = filteredEntryGroup1.isReadOnly();
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals("@=ig:7=4", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertFalse(boolean0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
  }

  @Test(timeout = 4000)
  public void test79()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "0K:F4w@lkRjdub");
      assertEquals("0K:F4w@lkRjdub", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertNotNull(filteredEntryGroup0);
      
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "0K:F4w@lkRjdub");
      assertEquals("0K:F4w@lkRjdub", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals("0K:F4w@lkRjdub", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getAllFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test80()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, "Warning - unknown keys");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("Warning - unknown keys", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "N0S");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("Warning - unknown keys", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("N0S", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry("");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("Warning - unknown keys", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("N0S", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      filteredEntryGroup1.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("Warning - unknown keys", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("N0S", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      filteredEntryGroup0.removeEntryChangeListener(filteredEntryGroup1);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals("Warning - unknown keys", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("N0S", filteredEntryGroup1.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getFeaturesInRange((Range) null);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test81()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn(0).when(entryGroup0).getSequenceLength();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, ",aa:Sec)");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(",aa:Sec)", filteredEntryGroup0.getFilterName());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(",aa:Sec)", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      FeatureChangeEvent featureChangeEvent0 = mock(FeatureChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.featureChanged(featureChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(",aa:Sec)", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      int int0 = filteredEntryGroup0.getSequenceLength();
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(",aa:Sec)", filteredEntryGroup0.getFilterName());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertEquals(0, int0);
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      
      filteredEntryGroup1.addFeatureChangeListener(filteredEntryGroup0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(",aa:Sec)", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      EntryGroupChangeEvent entryGroupChangeEvent0 = mock(EntryGroupChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.entryGroupChanged(entryGroupChangeEvent0);
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(",aa:Sec)", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      
      // Undeclared exception!
      try { 
        filteredEntryGroup1.filterFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test82()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertNotNull(filteredEntryGroup0);
      
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup1);
      
      Entry entry0 = filteredEntryGroup1.createEntry("");
      assertEquals("", filteredEntryGroup0.getFilterName());
      assertEquals(0, filteredEntryGroup0.refCount());
      assertEquals(0, filteredEntryGroup0.size());
      assertEquals(0, filteredEntryGroup1.refCount());
      assertEquals("", filteredEntryGroup1.getFilterName());
      assertEquals(0, filteredEntryGroup1.size());
      assertFalse(filteredEntryGroup0.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup1.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup0, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup1, filteredEntryGroup0);
      assertNull(entry0);
      
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "", "uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", "").when(entryGroup1).toString();
      doReturn((Entry) null).when(entryGroup1).getSequenceEntry();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, featureVector1, ",:");
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(",:", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotNull(filteredEntryGroup2);
      
      Entry entry1 = filteredEntryGroup2.getSequenceEntry();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(",:", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNull(entry1);
      
      filteredEntryGroup2.setDefaultEntry((Entry) null);
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(",:", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, (FeaturePredicate) null, ",:");
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(",:", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(",:", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertNotNull(filteredEntryGroup3);
      
      filteredEntryGroup3.ref();
      assertEquals(0, filteredEntryGroup2.refCount());
      assertEquals(",:", filteredEntryGroup2.getFilterName());
      assertEquals(0, filteredEntryGroup2.size());
      assertEquals(",:", filteredEntryGroup3.getFilterName());
      assertEquals(0, filteredEntryGroup3.refCount());
      assertEquals(0, filteredEntryGroup3.size());
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup2.equals((Object)filteredEntryGroup3));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup0));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup1));
      assertFalse(filteredEntryGroup3.equals((Object)filteredEntryGroup2));
      assertNotSame(filteredEntryGroup2, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup2, filteredEntryGroup3);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup0);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup1);
      assertNotSame(filteredEntryGroup3, filteredEntryGroup2);
      
      FeatureVector featureVector2 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((Feature) null).when(featureVector2).elementAt(anyInt());
      doReturn(2384).when(featureVector2).size();
      // Undeclared exception!
      try { 
        filteredEntryGroup3.filterFeatures(featureVector2);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test83()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((Entry) null).when(entryGroup0).getDefaultEntry();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      filteredEntryGroup1.getDefaultEntry();
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn("").when(entryVector0).toString();
      doReturn((Entry) null).when(entryVector0).elementAt(anyInt());
      doReturn(2).when(entryVector0).size();
      EntryGroup entryGroup1 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "uk.ac.sanger.artemis.FilteredEntryGroup$3", "9(68PMPFeKp+2y!p", "", "").when(entryGroup1).toString();
      doReturn(entryVector0).when(entryGroup1).getActiveEntries();
      doReturn(true).when(entryGroup1).isReadOnly();
      filteredEntryGroup0.createEntry("fasta_record");
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(entryGroup1, featurePredicate1, "");
      filteredEntryGroup2.isReadOnly();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup3 = new FilteredEntryGroup(filteredEntryGroup2, featureVector1, "");
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup3.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test84()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null, (Entry) null).when(entryGroup0).createEntry(anyString());
      doReturn((FeatureEnumeration) null).when(entryGroup0).features();
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "#`b}\"?Rnb.bmCI+");
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featurePredicate0).toString();
      doReturn(false).when(featurePredicate0).testPredicate(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, ":D%(1");
      filteredEntryGroup1.removeFeatureChangeListener(filteredEntryGroup0);
      filteredEntryGroup0.createEntry("m0#bb%<*H}1");
      filteredEntryGroup1.isActive((Entry) null);
      filteredEntryGroup0.createEntry("m0#bb%<*H}1");
      filteredEntryGroup0.addElement((Entry) null);
      filteredEntryGroup1.ref();
      int int0 = (-2444);
      int int1 = (-863);
      filteredEntryGroup1.contains((Feature) null);
      // Undeclared exception!
      try { 
        filteredEntryGroup0.filterFeatures();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test85()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((ActionController) null).when(entryGroup0).getActionController();
      doReturn((FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(0).when(entryGroup0).getSequenceLength();
      doReturn(false).when(entryGroup0).isActive(any(uk.ac.sanger.artemis.Entry.class));
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      filteredEntryGroup1.getSequenceLength();
      filteredEntryGroup1.createEntry();
      filteredEntryGroup1.isActive((Entry) null);
      FeaturePredicate featurePredicate1 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate1, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      EntryChangeEvent entryChangeEvent0 = mock(EntryChangeEvent.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup2.entryChanged(entryChangeEvent0);
      filteredEntryGroup2.getActionController();
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup0.reverseComplement();
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      // Undeclared exception!
      try { 
        filteredEntryGroup0.getFeaturesInRange(range0);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test86()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(entryVector0).toString();
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("un", "un", "un", "RNdg3(HN#&CP]ZE", "RNdg3(HN#&CP]ZE").when(entryGroup0).toString();
      doReturn(entryVector0, (EntryVector) null).when(entryGroup0).getActiveEntries();
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featurePredicate0, "<M8`)Xz>~:$>0k`LzI");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "<M8`)Xz>~:$>0k`LzI");
      filteredEntryGroup1.features();
      filteredEntryGroup1.unref();
      FilteredEntryGroup.FeatureEnumerator filteredEntryGroup_FeatureEnumerator0 = null;
      try {
        filteredEntryGroup_FeatureEnumerator0 = filteredEntryGroup1.new FeatureEnumerator();
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup$FeatureEnumerator", e);
      }
  }

  @Test(timeout = 4000)
  public void test87()  throws Throwable  {
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(featureVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn("", "", "uk.ac.sanger.artemis.FilteredEntryGroup$2", "uk.ac.sanger.artemis.FilteredEntryGroup$2", "uk.ac.sanger.artemis.FilteredEntryGroup$2").when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn(featureVector0, (FeatureVector) null).when(entryGroup0).getFeaturesInRange(any(uk.ac.sanger.artemis.io.Range.class));
      doReturn(0).when(entryGroup0).refCount();
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector1).toString();
      doReturn((Feature) null).when(featureVector1).elementAt(anyInt());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector1, "Xe3]ff*0O~:T~ PCA");
      FeaturePredicate featurePredicate0 = mock(FeaturePredicate.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featurePredicate0, "Xe3]ff*0O~:T~ PCA");
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      Range range1 = mock(Range.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup0.getFeaturesInRange(range1);
      filteredEntryGroup1.createEntry();
      filteredEntryGroup1.refCount();
      filteredEntryGroup0.featureAt((-1778));
      // Undeclared exception!
      try { 
        filteredEntryGroup1.getFeaturesInRange(range0);
        fail("Expecting exception: NullPointerException");
      
      } catch(NullPointerException e) {
         //
         // no message in exception (getMessage() returned null)
         //
         verifyException("uk.ac.sanger.artemis.FilteredEntryGroup", e);
      }
  }

  @Test(timeout = 4000)
  public void test88()  throws Throwable  {
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, (String) null, (String) null).when(entryGroup0).toString();
      doReturn((Entry) null).when(entryGroup0).createEntry();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn((Entry) null, (Entry) null).when(entryGroup0).elementAt(anyInt());
      doReturn((ActionController) null, (ActionController) null).when(entryGroup0).getActionController();
      doReturn((EntryVector) null).when(entryGroup0).getActiveEntries();
      doReturn((Entry) null).when(entryGroup0).getSequenceEntry();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0, 0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(false, false).when(entryGroup0).removeElement(any(uk.ac.sanger.artemis.Entry.class));
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, (FeaturePredicate) null, "");
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null).when(featureVector0).toString();
      doReturn(0).when(featureVector0).size();
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, featureVector0, "");
      filteredEntryGroup1.elementAt((-1084));
      filteredEntryGroup0.setIsActive((Entry) null, false);
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((String) null).when(featureVector1).toString();
      doReturn(0).when(featureVector1).indexOf(any(uk.ac.sanger.artemis.Feature.class));
      FilteredEntryGroup filteredEntryGroup2 = new FilteredEntryGroup(filteredEntryGroup1, featureVector1, "uk.ac.sanger.artemis.FilteredEntryGroup$3");
      filteredEntryGroup2.getActionController();
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup1.getFeaturesInIndexRange(0, (-1));
      int int0 = filteredEntryGroup1.getAllFeaturesCount();
      filteredEntryGroup1.ref();
      filteredEntryGroup0.addFeatureChangeListener((FeatureChangeListener) null);
      filteredEntryGroup0.getActionController();
      filteredEntryGroup0.removeEntryGroupChangeListener((EntryGroupChangeListener) null);
      filteredEntryGroup1.hasUnsavedChanges();
      filteredEntryGroup0.createFeature();
      filteredEntryGroup2.indexOf((Feature) null);
      filteredEntryGroup1.getActiveEntries();
      filteredEntryGroup0.elementAt(0);
      filteredEntryGroup1.getSequenceEntry();
      filteredEntryGroup2.removeElement((Entry) null);
      filteredEntryGroup0.removeElement((Entry) null);
      filteredEntryGroup0.createEntry();
      int int1 = filteredEntryGroup1.indexOf((Entry) null);
      assertTrue(int1 == int0);
  }

  @Test(timeout = 4000)
  public void test89()  throws Throwable  {
      EntryVector entryVector0 = mock(EntryVector.class, new ViolatedAssumptionAnswer());
      doReturn(0).when(entryVector0).size();
      EntryGroup entryGroup0 = mock(EntryGroup.class, new ViolatedAssumptionAnswer());
      doReturn((String) null, (String) null, (String) null, "Could not understand the start or end base of a GFF feature: ", (String) null).when(entryGroup0).toString();
      doReturn((Feature) null).when(entryGroup0).createFeature();
      doReturn(entryVector0).when(entryGroup0).getActiveEntries();
      doReturn((Bases) null).when(entryGroup0).getBases();
      doReturn(false).when(entryGroup0).hasUnsavedChanges();
      doReturn(0).when(entryGroup0).indexOf(any(uk.ac.sanger.artemis.Entry.class));
      doReturn(0).when(entryGroup0).size();
      doReturn((EntryGroup) null).when(entryGroup0).truncate(any(uk.ac.sanger.artemis.io.Range.class));
      FeatureVector featureVector0 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      FilteredEntryGroup filteredEntryGroup0 = new FilteredEntryGroup(entryGroup0, featureVector0, "");
      FeatureVector featureVector1 = mock(FeatureVector.class, new ViolatedAssumptionAnswer());
      doReturn((-1056)).when(featureVector1).size();
      filteredEntryGroup0.filterFeatures(featureVector1);
      FilteredEntryGroup filteredEntryGroup1 = new FilteredEntryGroup(filteredEntryGroup0, (FeaturePredicate) null, "");
      filteredEntryGroup1.getAllFeatures();
      filteredEntryGroup0.createFeature();
      filteredEntryGroup1.indexOf((Feature) null);
      filteredEntryGroup1.setIsActive((Entry) null, true);
      int int0 = filteredEntryGroup1.indexOf((Feature) null);
      filteredEntryGroup0.setDefaultEntry((Entry) null);
      Range range0 = mock(Range.class, new ViolatedAssumptionAnswer());
      filteredEntryGroup1.truncate(range0);
      filteredEntryGroup1.unref();
      filteredEntryGroup0.getBases();
      filteredEntryGroup0.reverseComplement();
      filteredEntryGroup0.setIsActive(5, false);
      filteredEntryGroup1.hasUnsavedChanges();
      filteredEntryGroup0.unref();
      filteredEntryGroup0.addEntryChangeListener((EntryChangeListener) null);
      int int1 = filteredEntryGroup1.size();
      assertFalse(int1 == int0);
  }
}
