@Test(expected = UnexpectedInvocation.class)
  public void verifyAllWithUnverifiedReplayOnSameInstance(final Dependency mock2) {
    mock.editABunchMoreStuff();
    mock2.editABunchMoreStuff();

    new FullVerifications(mock2) {
      {
        mock.editABunchMoreStuff();
      }
    };
  }
  @Test
  public void verifyAllInvocationsToOnlyOneOfTwoMockedTypes(AnotherDependency mock2) {
    exerciseCodeUnderTest();
    mock2.doSomething();

    new FullVerifications(mock) {
      {
        mock.prepare();
        mock.setSomething(anyInt);
        minTimes = 1;
        maxTimes = 2;
        mock.editABunchMoreStuff();
        mock.save();
        times = 1;
      }
    };

    new FullVerifications(mock.getClass()) {
      {
        mock.prepare();
        mock.setSomething(anyInt);
        minTimes = 1;
        maxTimes = 2;
        mock.editABunchMoreStuff();
        mock.save();
        times = 1;
      }
    };
  }
  @Test
  public void verifyAllInvocationsToOneOfTwoMocksInIteratingBlock(AnotherDependency mock2) {
    mock2.doSomething();
    mock.setSomething(123);
    mock.save();
    mock2.doSomethingElse(1);
    mock.setSomething(45);
    mock.save();
    mock2.doSomethingElse(2);

    new FullVerifications(2, mock) {
      {
        mock.setSomething(anyInt);
        mock.save();
      }
    };
  }
  @Test(expected = MissingInvocation.class)
  public void verifyAllWithReplayOnDifferentInstanceWhenShouldBeSame(final Dependency mock2) {
    mock2.editABunchMoreStuff();

    new FullVerificationsInOrder(mock2) {
      {
        mock.editABunchMoreStuff();
      }
    };
  }
  @Test
  public void verifyAllInvocationsWithReplayOnSameInstance(final Dependency mock2) {
    mock2.editABunchMoreStuff();

    new FullVerifications(mock2) {
      {
        mock2.editABunchMoreStuff();
      }
    };
  }
  @Test
  public void verifyNoInvocationsOnOneOfTwoMockedDependenciesBeyondThoseRecordedAsExpected(
      final AnotherDependency mock2) {
    new NonStrictExpectations() {
      {
        mock.setSomething(anyInt);
        minTimes = 1;
        mock2.doSomething();
        times = 1;
      }
    };

    mock.prepare();
    mock.setSomething(1);
    mock.setSomething(2);
    mock.save();
    mock2.doSomething();

    new FullVerifications(mock2) {};
  }
  @Test(expected = UnexpectedInvocation.class)
  public void unverifiedStaticInvocationForSpecifiedSubclassInstance(final SubDependency mock2) {
    mock2.getValue();
    Dependency.staticMethod("test");

    new FullVerificationsInOrder(1, mock2) {
      {
        mock2.getValue();
      }
    };
  }
  @Test(expected = UnexpectedInvocation.class)
  public void verifyAllInvocationsToSubclassMethods_whenNotVerified(final SubDependency mock2) {
    mock.prepare();
    mock2.getValue();

    new FullVerificationsInOrder(1, mock2.getClass()) {
      {
        mock.prepare();
      }
    };
  }
  @Test
  public void verifyAllInvocationsToSubclassMethods(final SubDependency mock2) {
    mock.prepare();
    mock2.getValue();

    new FullVerifications(1, mock2.getClass()) {
      {
        mock2.getValue();
      }
    };
  }
  @Test(expected = UnexpectedInvocation.class)
  public void verifyAllInvocationsToMethodsOfBaseClassAndOfSubclass_whenSubclassMethodNotVerified(
      final SubDependency mock2) {
    mock.prepare();
    mock2.getValue();

    new FullVerifications(mock2) {
      {
        mock.prepare();
      }
    };
  }
  @Test
  public void verifyNoInvocationsOccurredOnMockedDependencyWithOneHavingOccurred(
      AnotherDependency mock2) {
    mock2.doSomething();
    mock.editABunchMoreStuff();

    try {
      new FullVerifications(mock) {};
      fail();
    } catch (UnexpectedInvocation e) {
      assertTrue(e.getMessage().contains("editABunchMoreStuff()"));
    }
  }
  @Test
  public void verifyAllInvocationsToInheritedMethods(SubDependency mock2) {
    mock.prepare();
    mock2.getValue();

    new FullVerificationsInOrder(1, mock) {
      {
        mock.prepare();
      }
    };
    new FullVerificationsInOrder(Dependency.class) {
      {
        mock.prepare();
      }
    };
  }
  @Test
  public void verifyStaticInvocationForSpecifiedMockInstance(final AnotherDependency mock2) {
    mock2.doSomething();
    AnotherDependency.staticMethod();
    mock2.doSomethingElse(1);
    mock.editABunchMoreStuff();
    mock2.doSomethingElse(2);

    new FullVerificationsInOrder(mock2) {
      {
        mock2.doSomething();
        AnotherDependency.staticMethod();
        mock2.doSomethingElse(anyInt);
        mock2.doSomethingElse(anyInt);
      }
    };
  }
 private void exerciseCodeUnderTest() {
   mock.prepare();
   mock.setSomething(123);
   mock.editABunchMoreStuff();
   mock.save();
 }