/*
 *  Copyright (c) 2013-2015 Erik Doernenburg and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 *  not use these files except in compliance with the License. You may obtain
 *  a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 *  License for the specific language governing permissions and limitations
 *  under the License.
 */

#import <XCTest/XCTest.h>
#import <OCMock/OCMock.h>
#import <objc/runtime.h>

#if TARGET_OS_IPHONE
#define NSRect CGRect
#define NSZeroRect CGRectZero
#define NSMakeRect CGRectMake
#define valueWithRect valueWithCGRect
#endif

#pragma mark   Helper classes

@interface TestClassWithSimpleMethod : NSObject
+ (NSUInteger)initializeCallCount;
- (NSString *)foo;
@end

@implementation TestClassWithSimpleMethod

static NSUInteger initializeCallCount = 0;

+ (void)initialize
{
    initializeCallCount += 1;
}

+ (NSUInteger)initializeCallCount
{
    return initializeCallCount;
}

- (NSString *)foo
{
    return @"Foo";
}

@end


@interface TestClassThatCallsSelf : NSObject
{
    int methodInt;
}

- (NSString *)method1;
- (NSString *)method2;
- (NSRect)methodRect1;
- (NSRect)methodRect2;
- (int)methodInt;
- (void)methodVoid;
- (void)setMethodInt:(int)anInt;
@end

@implementation TestClassThatCallsSelf

- (NSString *)method1
{
	id retVal = [self method2];
	return retVal;
}

- (NSString *)method2
{
	return @"Foo";
}


- (NSRect)methodRect1
{
	NSRect retVal = [self methodRect2];
	return retVal;
}

- (NSRect)methodRect2
{
	return NSMakeRect(10, 10, 10, 10);
}

- (int)methodInt
{
	return methodInt;
}

- (void)methodVoid
{
}

- (void)setMethodInt:(int)anInt
{
	methodInt = anInt;
}

@end


@interface NSObject(OCMCategoryForTesting)

- (NSString *)categoryMethod;

@end

@implementation NSObject(OCMCategoryForTesting)

- (NSString *)categoryMethod
{
    return @"Foo-Category";
}

@end


@interface OCMockObjectPartialMocksTests : XCTestCase
{
    int numKVOCallbacks;
}

@end


@implementation OCMockObjectPartialMocksTests

#pragma mark   Tests for stubbing with partial mocks

- (void)testStubsMethodsOnPartialMock
{
	TestClassWithSimpleMethod *object = [[TestClassWithSimpleMethod alloc] init];
	id mock = [OCMockObject partialMockForObject:object];
	[[[mock stub] andReturn:@"hi"] foo];
	XCTAssertEqualObjects(@"hi", [mock foo], @"Should have returned stubbed value");
}

- (void)testForwardsUnstubbedMethodsCallsToRealObjectOnPartialMock
{
	TestClassWithSimpleMethod *object = [[TestClassWithSimpleMethod alloc] init];
	id mock = [OCMockObject partialMockForObject:object];
	XCTAssertEqualObjects(@"Foo", [mock foo], @"Should have returned value from real object.");
}

//- (void)testForwardsUnstubbedMethodsCallsToRealObjectOnPartialMockForTollFreeBridgedClasses
//{
//	mock = [OCMockObject partialMockForObject:[NSString stringWithString:@"hello2"]];
//	STAssertEqualObjects(@"HELLO2", [mock uppercaseString], @"Should have returned value from real object.");
//}

- (void)testStubsMethodOnRealObjectReference
{
	TestClassWithSimpleMethod *realObject = [[TestClassWithSimpleMethod alloc] init];
	id mock = [OCMockObject partialMockForObject:realObject];
	[[[mock stub] andReturn:@"TestFoo"] foo];
	XCTAssertEqualObjects(@"TestFoo", [realObject foo], @"Should have stubbed method.");
}

- (void)testCallsToSelfInRealObjectAreShadowedByPartialMock
{
	TestClassThatCallsSelf *realObject = [[TestClassThatCallsSelf alloc] init];
	id mock = [OCMockObject partialMockForObject:realObject];
	[[[mock stub] andReturn:@"FooFoo"] method2];
	XCTAssertEqualObjects(@"FooFoo", [mock method1], @"Should have called through to stubbed method.");
}

- (void)testCallsToSelfInRealObjectStructReturnAreShadowedByPartialMock
{
	TestClassThatCallsSelf *realObject = [[TestClassThatCallsSelf alloc] init];
	id mock = [OCMockObject partialMockForObject:realObject];
    [[[mock stub] andReturnValue:OCMOCK_VALUE(NSZeroRect)] methodRect2];
#if TARGET_OS_IPHONE
#define NSEqualRects CGRectEqualToRect
#endif
    XCTAssertTrue(NSEqualRects(NSZeroRect, [mock methodRect1]), @"Should have called through to stubbed method.");
}

- (void)testInvocationsOfNSObjectCategoryMethodsCanBeStubbed
{
    TestClassThatCallsSelf *realObject = [[TestClassThatCallsSelf alloc] init];
   	id mock = [OCMockObject partialMockForObject:realObject];
    [[[mock stub] andReturn:@"stubbed"] categoryMethod];
    XCTAssertEqualObjects(@"stubbed", [realObject categoryMethod], @"Should have stubbed NSObject's method");
}


#pragma mark   Tests for behaviour when setting up partial mocks

- (void)testPartialMockClassOverrideReportsOriginalClass
{
	TestClassThatCallsSelf *realObject = [[TestClassThatCallsSelf alloc] init];
	Class origClass = [realObject class];
	id mock = [OCMockObject partialMockForObject:realObject];
	XCTAssertEqualObjects([realObject class], origClass, @"Override of -class method did not work");
	XCTAssertEqualObjects([mock class], origClass, @"Mock proxy -class method did not work");
	XCTAssertFalse(origClass == object_getClass(realObject), @"Subclassing did not work");
	[mock stopMocking];
	XCTAssertEqualObjects([realObject class], origClass, @"Classes different after stopMocking");
	XCTAssertEqualObjects(object_getClass(realObject), origClass, @"Classes different after stopMocking");
}

- (void)testInitializeIsNotCalledOnMockedClass
{
    NSUInteger countBefore = [TestClassWithSimpleMethod initializeCallCount];

    TestClassWithSimpleMethod *object = [[TestClassWithSimpleMethod alloc] init];
    id mock = [OCMockObject partialMockForObject:object];
    [[[mock expect] andForwardToRealObject] foo];
    [object foo];

    NSUInteger countAfter = [TestClassWithSimpleMethod initializeCallCount];

    XCTAssertEqual(countBefore, countAfter, @"Creating a mock should not have resulted in call to +initialize");
}


- (void)testRefusesToCreateTwoPartialMocksForTheSameObject
{
    id object = [[TestClassThatCallsSelf alloc] init];

    id partialMock1 = [OCMockObject partialMockForObject:object];

    XCTAssertNotNil(partialMock1, @"Should have created first partial mock.");
    XCTAssertThrows([OCMockObject partialMockForObject:object], @"Should not have allowed creation of second partial mock");
}

- (void)testRefusesToCreatePartialMockForTollFreeBridgedClasses
{
    id object = (id)CFBridgingRelease(CFStringCreateWithCString(kCFAllocatorDefault, "foo", kCFStringEncodingASCII));
    XCTAssertThrowsSpecificNamed([OCMockObject partialMockForObject:object],
                                 NSException,
                                 NSInvalidArgumentException,
                                 @"should throw NSInvalidArgumentException exception");
}

#if TARGET_RT_64_BIT

- (void)testRefusesToCreatePartialMockForTaggedPointers
{
    NSDate *object = [NSDate dateWithTimeIntervalSince1970:0];
    XCTAssertThrowsSpecificNamed([OCMockObject partialMockForObject:object],
                                 NSException,
                                 NSInvalidArgumentException,
                                 @"should throw NSInvalidArgumentException exception");
}

#endif

- (void)testRefusesToCreatePartialMockForNilObject
{
    XCTAssertThrows(OCMPartialMock(nil));
}


#pragma mark   Tests for KVO interaction with mocks

/* Starting KVO observations on an already-mocked object generally should work. */
- (void)testAddingKVOObserverOnPartialMock
{
	static char *MyContext;
	TestClassThatCallsSelf *realObject = [[TestClassThatCallsSelf alloc] init];
	Class origClass = [realObject class];

	id mock = [OCMockObject partialMockForObject:realObject];
	Class ourSubclass = object_getClass(realObject);

	[realObject addObserver:self forKeyPath:@"methodInt" options:NSKeyValueObservingOptionNew context:MyContext];
	Class kvoClass = object_getClass(realObject);

	/* KVO additionally overrides the -class method, but they return the superclass of their special
	   subclass, which in this case is the special mock subclass */
	XCTAssertEqualObjects([realObject class], ourSubclass, @"KVO override of class did not return our subclass");
	XCTAssertFalse(ourSubclass == kvoClass, @"KVO with subclass did not work");

	[realObject setMethodInt:45];
	XCTAssertEqual(numKVOCallbacks, 1, @"did not get subclass KVO notification");
	[mock setMethodInt:47];
	XCTAssertEqual(numKVOCallbacks, 2, @"did not get mock KVO notification");

	[realObject removeObserver:self forKeyPath:@"methodInt" context:MyContext];
	XCTAssertEqualObjects([realObject class], origClass, @"Classes different after stopKVO");
	XCTAssertEqualObjects(object_getClass(realObject), ourSubclass, @"Classes different after stopKVO");

	[mock stopMocking];
	XCTAssertEqualObjects([realObject class], origClass, @"Classes different after stopMocking");
	XCTAssertEqualObjects(object_getClass(realObject), origClass, @"Classes different after stopMocking");
}

/* Mocking a class which already has KVO observations does not work, but does not crash. */
- (void)testPartialMockOnKVOObserved
{
	static char *MyContext;
	TestClassThatCallsSelf *realObject = [[TestClassThatCallsSelf alloc] init];
	Class origClass = [realObject class];
    
	[realObject addObserver:self forKeyPath:@"methodInt" options:NSKeyValueObservingOptionNew context:MyContext];
	Class kvoClass = object_getClass(realObject);

	id mock = [OCMockObject partialMockForObject:realObject];
	Class ourSubclass = object_getClass(realObject);
    
	XCTAssertEqualObjects([realObject class], origClass, @"We did not preserve the original [self class]");
	XCTAssertFalse(ourSubclass == kvoClass, @"KVO with subclass did not work");
    
	/* Due to the way we replace the object's class, the KVO class gets overwritten and
	   KVO notifications stop functioning.  If we did not do this, the presence of the mock
	   subclass would cause KVO to crash, at least without further tinkering. */
	[realObject setMethodInt:45];
//	STAssertEquals(numKVOCallbacks, 1, @"did not get subclass KVO notification");
	XCTAssertEqual(numKVOCallbacks, 0, @"got subclass KVO notification");
	[mock setMethodInt:47];
//	STAssertEquals(numKVOCallbacks, 2, @"did not get mock KVO notification");
	XCTAssertEqual(numKVOCallbacks, 0, @"got mock KVO notification");

	[mock stopMocking];
	XCTAssertEqualObjects([realObject class], origClass, @"Classes different after stopMocking");
//	STAssertEqualObjects(object_getClass(realObject), kvoClass, @"KVO class different after stopMocking");
	XCTAssertEqualObjects(object_getClass(realObject), origClass, @"class different after stopMocking");

	[realObject removeObserver:self forKeyPath:@"methodInt" context:MyContext];
	XCTAssertEqualObjects([realObject class], origClass, @"Classes different after stopKVO");
	XCTAssertEqualObjects(object_getClass(realObject), origClass, @"Classes different after stopKVO");
}


- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
	numKVOCallbacks++;
}


#pragma mark   Tests for end of stubbing with partial mocks

- (void)testReturnsToRealImplementationWhenExpectedCallOccurred
{
    TestClassWithSimpleMethod *realObject = [[TestClassWithSimpleMethod alloc] init];
   	id mock = [OCMockObject partialMockForObject:realObject];
   	[[[mock expect] andReturn:@"TestFoo"] foo];
   	XCTAssertEqualObjects(@"TestFoo", [realObject foo], @"Should have stubbed method.");
   	XCTAssertEqualObjects(@"Foo", [realObject foo], @"Should have 'unstubbed' method.");
}

- (void)testRestoresObjectWhenStopped
{
	TestClassWithSimpleMethod *realObject = [[TestClassWithSimpleMethod alloc] init];
	id mock = [OCMockObject partialMockForObject:realObject];
	[[[mock stub] andReturn:@"TestFoo"] foo];
	XCTAssertEqualObjects(@"TestFoo", [realObject foo], @"Should have stubbed method.");
	XCTAssertEqualObjects(@"TestFoo", [realObject foo], @"Should have stubbed method.");
	[mock stopMocking];
	XCTAssertEqualObjects(@"Foo", [realObject foo], @"Should have 'unstubbed' method.");
}


#pragma mark   Tests for explicit forward to real object with partial mocks

- (void)testForwardsToRealObjectWhenSetUpAndCalledOnMock
{
	TestClassWithSimpleMethod *realObject = [[TestClassWithSimpleMethod alloc] init];
	id mock = [OCMockObject partialMockForObject:realObject];
    
	[[[mock expect] andForwardToRealObject] foo];
	XCTAssertEqual(@"Foo", [mock foo], @"Should have called method on real object.");
    
	[mock verify];
}

- (void)testForwardsToRealObjectWhenSetUpAndCalledOnRealObject
{
	TestClassWithSimpleMethod *realObject = [[TestClassWithSimpleMethod alloc] init];
	id mock = [OCMockObject partialMockForObject:realObject];
	
	[[[mock expect] andForwardToRealObject] foo];
	XCTAssertEqual(@"Foo", [realObject foo], @"Should have called method on real object.");
	
	[mock verify];
}

- (void)testReturnValueFromRealObjectShouldBeReturnedEvenWithPrecedingAndCall
{
  TestClassThatCallsSelf *object = [[TestClassThatCallsSelf alloc] init];
  OCMockObject *mock = OCMPartialMock(object);
  [[[[mock stub] andCall:@selector(firstReturnValueMethod) onObject:self] andForwardToRealObject] method2];
  XCTAssertEqualObjects([object method2], @"Foo", @"Should have returned value from real object.");
}

- (NSString *)firstReturnValueMethod
{
    return @"Bar";
}

- (void)testExpectedMethodCallsExpectedMethodWithExpectationOrdering
{
    TestClassThatCallsSelf *object = [[TestClassThatCallsSelf alloc] init];
    id mock = OCMPartialMock(object);
    [mock setExpectationOrderMatters:YES];
    [[[mock expect] andForwardToRealObject] method1];
    [[[mock expect] andForwardToRealObject] method2];
    XCTAssertNoThrow([object method1], @"Calling an expected method that internally calls another expected method should not make expectations appear to be out of order.");
}


#pragma mark   Tests for method swizzling with partial mocks

- (NSString *)differentMethodInDifferentClass
{
	return @"swizzled!";
}

- (void)testImplementsMethodSwizzling
{
	// using partial mocks and the indirect return value provider
	TestClassThatCallsSelf *foo = [[TestClassThatCallsSelf alloc] init];
	id mock = [OCMockObject partialMockForObject:foo];
	[[[mock stub] andCall:@selector(differentMethodInDifferentClass) onObject:self] method1];
	XCTAssertEqualObjects(@"swizzled!", [foo method1], @"Should have returned value from different method");
}


- (void)aMethodWithVoidReturn
{
}

- (void)testMethodSwizzlingWorksForVoidReturns
{
	TestClassThatCallsSelf *foo = [[TestClassThatCallsSelf alloc] init];
	id mock = [OCMockObject partialMockForObject:foo];
	[[[mock stub] andCall:@selector(aMethodWithVoidReturn) onObject:self] methodVoid];
	XCTAssertNoThrow([foo method1], @"Should have worked.");
}


@end