public void EqualsToAnotherProxy()
 {
     ProxyInstance mockProxy = new ProxyInstance(null);
     ProxyMethodPair pair1 = new ProxyMethodPair(mockProxy, endsWith);
     ProxyMethodPair pair2 = new ProxyMethodPair(mockProxy, endsWith);
     Assert.Equal(pair1, pair2);
     Assert.Equal(pair2, pair1); //make sure that it works both ways
 }
 public void NotEqualIfNotSameMethod()
 {
     ProxyInstance mockProxy = new ProxyInstance(null);
     ProxyMethodPair pair1 = new ProxyMethodPair(mockProxy, endsWith);
     ProxyMethodPair pair2 = new ProxyMethodPair(mockProxy, startsWith);
     Assert.NotEqual(pair1, pair2);
     Assert.NotEqual(pair2, pair1); //make sure that it works both ways
 }
        public void MethodNullThrows()
        {
            ProxyInstance mockProxy = new ProxyInstance(null);

            string expectedMessage="Value cannot be null.\r\nParameter name: method";
            ArgumentNullException ex = Assert.Throws<ArgumentNullException>(
                                                 () => new ProxyMethodPair(mockProxy, null));
            Assert.Equal(expectedMessage, ex.Message);
        }
 public ReplayMockStateTests()
 {
     mocks = new MockRepository();
     proxy = new ProxyInstance(mocks);
     startsWith = CreateMethodInfo();
     record = new RecordMockState(proxy, mocks);
     record.MethodCall(new FakeInvocation(startsWith), startsWith, "2");
     replay = new ReplayMockState(record);
 }
 public void CantMoveToReplayStateWithoutclosingLastMethod()
 {
     MockRepository mocks = new MockRepository();
     ProxyInstance proxy = new ProxyInstance(mocks);
     RecordMockState recordState = new RecordMockState(proxy, mocks);
     recordState.MethodCall(new FakeInvocation(method), method, "");
     string expectedMessage="Previous method 'String.StartsWith(\"\");' requires a return value or an exception to throw.";
     InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
         () => recordState.Replay());
     Assert.Equal(expectedMessage, ex.Message);
 }
        public void EqualsTest()
        {
            ProxyInstance proxy1 = new ProxyInstance(null);
            ProxyInstance proxy2 = new ProxyInstance(null);
            MethodInfo method1 = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) }),
                method2 = endsWith;
            IExpectation expectation1 = new AnyArgsExpectation(new FakeInvocation(method1), new Range(1, 1)),
                expectation2 = new AnyArgsExpectation(new FakeInvocation(method2), new Range(1, 1));
            ProxyMethodExpectationTriplet same1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
                same2 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1);
            Assert.Equal(same1, same2);
            Assert.Equal(same2, same1);

            ProxyMethodExpectationTriplet proxyDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
                proxyDiff2 = new ProxyMethodExpectationTriplet(proxy2, method1, expectation1);
            Assert.NotEqual(proxyDiff2, proxyDiff1);
            Assert.NotEqual(proxyDiff1, proxyDiff2);

            ProxyMethodExpectationTriplet methodDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
                methodDiff2 = new ProxyMethodExpectationTriplet(proxy1, method2, expectation1);

            Assert.NotEqual(methodDiff1, methodDiff2);
            Assert.NotEqual(methodDiff2, methodDiff1);

            ProxyMethodExpectationTriplet expectationDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
                expectationDiff2 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation2);

            Assert.NotEqual(expectationDiff1, expectationDiff2);
            Assert.NotEqual(expectationDiff2, expectationDiff1);

            ProxyMethodExpectationTriplet allDiff1 = new ProxyMethodExpectationTriplet(proxy1, method1, expectation1),
                allDiff2 = new ProxyMethodExpectationTriplet(proxy2, method2, expectation2);

            Assert.NotEqual(allDiff1, allDiff2);
            Assert.NotEqual(allDiff2, allDiff1);
        }
 public void MethodCallOnRecordsAddToExpectations()
 {
     MockRepository mocks = new MockRepository();
     ProxyInstance proxy = new ProxyInstance(mocks);
     RecordMockState recordState = new RecordMockState(proxy, mocks);
     recordState.MethodCall(new FakeInvocation(method), method, "");
     recordState.LastExpectation.ReturnValue = true;
     Assert.NotNull(Get.Recorder(mocks).GetAllExpectationsForProxyAndMethod(proxy, method));
     recordState.MethodCall(new FakeInvocation(method), method, "");
     recordState.LastExpectation.ReturnValue = true;
     Assert.Equal(2, recordState.MethodCallsCount);
 }
 public void MethodCallAddExpectation()
 {
     MockRepository mocks = new MockRepository();
     ProxyInstance proxy = new ProxyInstance(mocks);
     RecordMockState recordState = new RecordMockState(proxy, mocks);
     recordState.MethodCall(new FakeInvocation(method), method, "1");
     recordState.LastExpectation.ReturnValue = false;
     Assert.Equal(1, Get.Recorder(mocks).GetAllExpectationsForProxyAndMethod(proxy, method).Count);
     recordState.MethodCall(new FakeInvocation(method), method, "2");
     recordState.LastExpectation.ReturnValue = false;
     Assert.Equal(2, Get.Recorder(mocks).GetAllExpectationsForProxyAndMethod(proxy, method).Count);
 }
 public void NotEqualToNull()
 {
     ProxyInstance mockProxy = new ProxyInstance(null);
     ProxyMethodPair pair1 = new ProxyMethodPair(mockProxy, endsWith);
     Assert.False(pair1.Equals(null));
 }
 public ProxyMethodExpectationTripletTests()
 {
     endsWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
     expectation = new AnyArgsExpectation(new FakeInvocation(endsWith), new Range(1, 1));
     proxy = new ProxyInstance(null);
 }