private void assertReportWrongNumberOfMatchers(TestInterface testObject) {
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);

    recorder
        .record(testObject.methodWithArguments((String) recorder.matchObject(Any.ANY), 10))
        .andReturn("value");
  }
  private void assertUseCustomMatcher(TestInterface testObject) {
    String returnedValue = "returnedValue";
    String stringArg = "stringarg";
    int intArg = -1;
    Recorder<TestInterface> recorder = new Recorder<TestInterface>(testObject);
    recorder
        .record(
            testObject.methodWithArguments(
                (String)
                    recorder.matchObject(
                        new Matcher() {
                          @Override
                          public boolean matches(Object aActual) {
                            return ((String) aActual).startsWith("s");
                          }
                        }),
                recorder.matchInt(
                    new Matcher() {
                      @Override
                      public boolean matches(Object aActual) {
                        return ((Integer) aActual).intValue() < 0;
                      }
                    })))
        .andReturn(returnedValue);

    String actual = testObject.methodWithArguments(stringArg, intArg);
    assertEquals(actual, returnedValue);
  }
  private void assertThrowOnVoidMethod(TestInterface testObject) {
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);

    testObject.returnNothing();
    recorder.recordForLastCall().andThrow(new RuntimeException());

    testObject.returnNothing();
  }
  private void assertVoidMethodWithParamMatching(TestInterface testObject) {
    Recorder<TestInterface> recorder = new Recorder<TestInterface>(testObject);

    String arg = "arg";
    testObject.methodWithArguments(arg);
    recorder.recordForLastCall().andThrow(new RuntimeException());

    testObject.methodWithArguments("otherstring");
    testObject.methodWithArguments(arg);
  }
  private void assertRecordingUseArgumentMatching(TestInterface testObject) {
    String stringArg = "arg";
    int intArg = 11;
    String returnedValue = "returnedValue";
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);
    recorder.record(testObject.methodWithArguments(stringArg, intArg)).andReturn(returnedValue);

    String actual = testObject.methodWithArguments("otherArg", -1);
    assertNull(actual);

    actual = testObject.methodWithArguments(stringArg, intArg);
    assertEquals(actual, returnedValue);
  }
  private void assertUseLooseArgumentMatching(TestInterface testObject) {
    String returnedValue = "returnedValue";
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);
    recorder
        .record(
            testObject.methodWithArguments(
                (String) recorder.matchObject(Any.ANY), recorder.matchInt(Any.ANY)))
        .andReturn(returnedValue);

    String actual = testObject.methodWithArguments("otherArg", -1);
    ;
    assertEquals(actual, returnedValue);
  }
  private void assertNullParametersMatched(TestInterface testObject) {
    String stringArg = null;
    int intArg = 11;
    String returnedValue = "returnedValue";
    Recorder<TestInterface> recorder = new Recorder<TestInterface>(testObject);
    recorder.record(testObject.methodWithArguments(stringArg, intArg)).andReturn(returnedValue);

    String actual = testObject.methodWithArguments("string", -1);
    assertNull(actual);

    actual = testObject.methodWithArguments(stringArg, intArg);
    assertEquals(actual, returnedValue);
  }
  private void assertReturnRecordedValue(TestInterface testObject) {
    String returnValue = "returnValue";
    Integer returnInteger = 10;

    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);
    recorder
        .record(testObject.returnObject())
        .andReturn(returnValue)
        .record(testObject.returnInteger())
        .andReturn(returnInteger);

    assertEquals(returnValue, testObject.returnObject());
    assertEquals(returnInteger, testObject.returnInteger());
  }
  private void assertEqMatcher(TestInterface testObject) {
    String returnedValue = "returnedValue";
    String stringArg = "stringarg";
    int intArg = -1;
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);
    recorder
        .record(
            testObject.methodWithArguments(
                (String) recorder.matchObject(new Eq(stringArg)),
                recorder.matchInt(new Eq(intArg))))
        .andReturn(returnedValue);

    String actual = testObject.methodWithArguments(stringArg, intArg);
    assertEquals(actual, returnedValue);
  }
 @Before
 public void setUp() throws Exception {
   driver = new FirefoxDriver();
   recorder = new Recorder();
   baseUrl = "http://10.0.0.107:8080/";
   driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
   driver.manage().window().maximize();
   recorder.startRecording(this.getClass().getName());
 }
 @After
 public void tearDown() throws Exception {
   recorder.stopRecording();
   driver.quit();
   String verificationErrorString = verificationErrors.toString();
   if (!"".equals(verificationErrorString)) {
     fail(verificationErrorString);
   }
 }
  private void assertCanModifyReturnValueForPrimitiveType(TestInterface testObject) {
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);

    boolean expectedBoolean = true;
    byte expectedByte = 9;
    char expectedChar = 10;
    short expectedShort = 11;
    int expectedInt = 12;
    long expectedLong = 13;
    float expectedFloat = 14.2f;
    double expectedDouble = 15.5d;
    recorder
        .record(testObject.returnBoolean())
        .andReturn(expectedBoolean)
        .record(testObject.returnByte())
        .andReturn(expectedByte)
        .record(testObject.returnChar())
        .andReturn(expectedChar)
        .record(testObject.returnShort())
        .andReturn(expectedShort)
        .record(testObject.returnInt())
        .andReturn(expectedInt)
        .record(testObject.returnLong())
        .andReturn(expectedLong)
        .record(testObject.returnFloat())
        .andReturn(expectedFloat)
        .record(testObject.returnDouble())
        .andReturn(expectedDouble);

    assertEquals(expectedBoolean, testObject.returnBoolean());
    assertEquals(expectedByte, testObject.returnByte());
    assertEquals(expectedChar, testObject.returnChar());
    assertEquals(expectedShort, testObject.returnShort());
    assertEquals(expectedInt, testObject.returnInt());
    assertEquals(expectedLong, testObject.returnLong());
    assertTrue(expectedFloat == testObject.returnFloat());
    assertTrue(expectedDouble == testObject.returnDouble());
  }
  private void assertRecodedExceptionThrown(TestInterface testObject) {
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);

    recorder.record(testObject.returnObject()).andThrow(new IllegalArgumentException());
    testObject.returnObject();
  }
 private void assertExceptionThrownIfReturnValueHasWrongType(TestInterface testObject) {
   Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);
   recorder.record(testObject.toString()).andReturn(new Long(10));
 }
  private void assertDoesNotAllowWrongTypeException(TestInterface testObject) throws IOException {
    Recorder<TestInterface> recorder = TestObject.createRecorder(testObject);

    testObject.throwDeclardeException();
    recorder.recordForLastCall().andThrow(new Exception());
  }