Move all ivars over to properties.

Author: dmaclach

Source/OCMock/OCClassMockObject.m

@@ -21,12 +21,13 @@
 #import "OCMInvocationStub.h"
 #import "NSMethodSignature+OCMAdditions.h"
 
+@interface OCClassMockObject ()
+  @property (nonatomic) Class mockedClass;
+  @property (nonatomic) Class originalMetaClass;
+  @property (nonatomic) Class classCreatedForNewMetaClass;
+@end
+
 @implementation OCClassMockObject
-{
-  Class mockedClass;
-  Class originalMetaClass;
-  Class classCreatedForNewMetaClass;
-}
 
 #pragma mark  Initialisers, description, accessors, etc.
 
@@ -36,7 +37,7 @@ - (id)initWithClass:(Class)aClass
 		[NSException raise:NSInvalidArgumentException format:@"Class cannot be Nil."];
 
 	self = [super init];
-	mockedClass = aClass;
+	self.mockedClass = aClass;
     [self prepareClassForClassMethodMocking];
 	return self;
 }
@@ -49,37 +50,37 @@ - (void)dealloc
 
 - (NSString *)description
 {
-	return [NSString stringWithFormat:@"OCClassMockObject(%@)", NSStringFromClass(mockedClass)];
+	return [NSString stringWithFormat:@"OCClassMockObject(%@)", NSStringFromClass(self.mockedClass)];
 }
 
 - (Class)mockedClass
 {
-	return mockedClass;
+	return _mockedClass;
 }
 
 
 #pragma mark  Extending/overriding superclass behaviour
 
 - (void)stopMocking
 {
-    if(originalMetaClass != nil)
+    if(self.originalMetaClass != nil)
     {
         [self stopMockingClassMethods];
     }
-    if(classCreatedForNewMetaClass != nil)
+    if(self.classCreatedForNewMetaClass != nil)
     {
         OCMDisposeSubclass(classCreatedForNewMetaClass);
-        classCreatedForNewMetaClass = nil;
+        self.classCreatedForNewMetaClass = nil;
     }
     [super stopMocking];
 }
 
 
 - (void)stopMockingClassMethods
 {
-    OCMSetAssociatedMockForClass(nil, mockedClass);
-    object_setClass(mockedClass, originalMetaClass);
-    originalMetaClass = nil;
+    OCMSetAssociatedMockForClass(nil, self.mockedClass);
+    object_setClass(self.mockedClass, self.originalMetaClass);
+  self.originalMetaClass = nil;
     /* created meta class will be disposed later because partial mocks create another subclass depending on it */
 }
 
@@ -97,32 +98,32 @@ - (void)addStub:(OCMInvocationStub *)aStub
 - (void)prepareClassForClassMethodMocking
 {
     /* the runtime and OCMock depend on string and array; we don't intercept methods on them to avoid endless loops */
-    if([[mockedClass class] isSubclassOfClass:[NSString class]] || [[mockedClass class] isSubclassOfClass:[NSArray class]])
+    if([[self.mockedClass class] isSubclassOfClass:[NSString class]] || [[self.mockedClass class] isSubclassOfClass:[NSArray class]])
         return;
 
     /* trying to replace class methods on NSManagedObject and subclasses of it doesn't work; see #339 */
-    if([mockedClass isSubclassOfClass:objc_getClass("NSManagedObject")])
+    if([self.mockedClass isSubclassOfClass:objc_getClass("NSManagedObject")])
         return;
 
     /* if there is another mock for this exact class, stop it */
-    id otherMock = OCMGetAssociatedMockForClass(mockedClass, NO);
+    id otherMock = OCMGetAssociatedMockForClass(self.mockedClass, NO);
     if(otherMock != nil)
         [otherMock stopMockingClassMethods];
 
-    OCMSetAssociatedMockForClass(self, mockedClass);
+    OCMSetAssociatedMockForClass(self, self.mockedClass);
 
     /* dynamically create a subclass and use its meta class as the meta class for the mocked class */
-    classCreatedForNewMetaClass = OCMCreateSubclass(mockedClass, mockedClass);
-    originalMetaClass = object_getClass(mockedClass);
-    id newMetaClass = object_getClass(classCreatedForNewMetaClass);
+    self.classCreatedForNewMetaClass = OCMCreateSubclass(self.mockedClass, self.mockedClass);
+  self.originalMetaClass = object_getClass(self.mockedClass);
+    id newMetaClass = object_getClass(self.classCreatedForNewMetaClass);
 
     /* create a dummy initialize method */
     Method myDummyInitializeMethod = class_getInstanceMethod([self mockObjectClass], @selector(initializeForClassObject));
     const char *initializeTypes = method_getTypeEncoding(myDummyInitializeMethod);
     IMP myDummyInitializeIMP = method_getImplementation(myDummyInitializeMethod);
     class_addMethod(newMetaClass, @selector(initialize), myDummyInitializeIMP, initializeTypes);
 
-    object_setClass(mockedClass, newMetaClass); // only after dummy initialize is installed (iOS9)
+    object_setClass(self.mockedClass, newMetaClass); // only after dummy initialize is installed (iOS9)
 
     /* point forwardInvocation: of the object to the implementation in the mock */
     Method myForwardMethod = class_getInstanceMethod([self mockObjectClass], @selector(forwardInvocationForClassObject:));
@@ -132,7 +133,7 @@ - (void)prepareClassForClassMethodMocking
     /* adding forwarder for most class methods (instance methods on meta class) to allow for verify after run */
     NSArray *methodBlackList = @[@"class", @"forwardingTargetForSelector:", @"methodSignatureForSelector:", @"forwardInvocation:", @"isBlock",
             @"instanceMethodForwarderForSelector:", @"instanceMethodSignatureForSelector:", @"resolveClassMethod:"];
-    [NSObject enumerateMethodsInClass:originalMetaClass usingBlock:^(Class cls, SEL sel) {
+    [NSObject enumerateMethodsInClass:self.originalMetaClass usingBlock:^(Class cls, SEL sel) {
         if((cls == object_getClass([NSObject class])) || (cls == [NSObject class]) || (cls == object_getClass(cls)))
             return;
         if(OCMIsApplePrivateMethod(cls, sel))
@@ -154,15 +155,15 @@ - (void)prepareClassForClassMethodMocking
 - (void)setupForwarderForClassMethodSelector:(SEL)selector
 {
     SEL aliasSelector = OCMAliasForOriginalSelector(selector);
-    if(class_getClassMethod(mockedClass, aliasSelector) != NULL)
+    if(class_getClassMethod(self.mockedClass, aliasSelector) != NULL)
         return;
 
-    Method originalMethod = class_getClassMethod(mockedClass, selector);
+    Method originalMethod = class_getClassMethod(self.mockedClass, selector);
     IMP originalIMP = method_getImplementation(originalMethod);
     const char *types = method_getTypeEncoding(originalMethod);
 
-    Class metaClass = object_getClass(mockedClass);
-    IMP forwarderIMP = [originalMetaClass instanceMethodForwarderForSelector:selector];
+    Class metaClass = object_getClass(self.mockedClass);
+    IMP forwarderIMP = [self.originalMetaClass instanceMethodForwarderForSelector:selector];
     class_addMethod(metaClass, aliasSelector, originalIMP, types);
     class_replaceMethod(metaClass, selector, forwarderIMP, types);
 }
@@ -193,10 +194,10 @@ - (void)initializeForClassObject
 
 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
 {
-    NSMethodSignature *signature = [mockedClass instanceMethodSignatureForSelector:aSelector];
+    NSMethodSignature *signature = [self.mockedClass instanceMethodSignatureForSelector:aSelector];
     if(signature == nil)
     {
-        signature = [NSMethodSignature signatureForDynamicPropertyAccessedWithSelector:aSelector inClass:mockedClass];
+        signature = [NSMethodSignature signatureForDynamicPropertyAccessedWithSelector:aSelector inClass:self.mockedClass];
     }
     return signature;
 }
@@ -208,22 +209,22 @@ - (Class)mockObjectClass
 
 - (Class)class
 {
-    return mockedClass;
+    return _mockedClass;
 }
 
 - (BOOL)respondsToSelector:(SEL)selector
 {
-    return [mockedClass instancesRespondToSelector:selector];
+    return [self.mockedClass instancesRespondToSelector:selector];
 }
 
 - (BOOL)isKindOfClass:(Class)aClass
 {
-    return [mockedClass isSubclassOfClass:aClass];
+    return [self.mockedClass isSubclassOfClass:aClass];
 }
 
 - (BOOL)conformsToProtocol:(Protocol *)aProtocol
 {
-    Class clazz = mockedClass;
+    Class clazz = self.mockedClass;
     while (clazz != nil) {
         if (class_conformsToProtocol(clazz, aProtocol)) {
             return YES;
@@ -259,52 +260,52 @@ @implementation OCClassMockObject(NSIsKindsImplementation)
 
 - (BOOL)isNSValue__
 {
-    return [mockedClass isSubclassOfClass:[NSValue class]];
+    return [self.mockedClass isSubclassOfClass:[NSValue class]];
 }
 
 - (BOOL)isNSTimeZone__
 {
-    return [mockedClass isSubclassOfClass:[NSTimeZone class]];
+    return [self.mockedClass isSubclassOfClass:[NSTimeZone class]];
 }
 
 - (BOOL)isNSSet__
 {
-    return [mockedClass isSubclassOfClass:[NSSet class]];
+    return [self.mockedClass isSubclassOfClass:[NSSet class]];
 }
 
 - (BOOL)isNSOrderedSet__
 {
-    return [mockedClass isSubclassOfClass:[NSOrderedSet class]];
+    return [self.mockedClass isSubclassOfClass:[NSOrderedSet class]];
 }
 
 - (BOOL)isNSNumber__
 {
-    return [mockedClass isSubclassOfClass:[NSNumber class]];
+    return [self.mockedClass isSubclassOfClass:[NSNumber class]];
 }
 
 - (BOOL)isNSDate__
 {
-    return [mockedClass isSubclassOfClass:[NSDate class]];
+    return [self.mockedClass isSubclassOfClass:[NSDate class]];
 }
 
 - (BOOL)isNSString__
 {
-    return [mockedClass isSubclassOfClass:[NSString class]];
+    return [self.mockedClass isSubclassOfClass:[NSString class]];
 }
 
 - (BOOL)isNSDictionary__
 {
-    return [mockedClass isSubclassOfClass:[NSDictionary class]];
+    return [self.mockedClass isSubclassOfClass:[NSDictionary class]];
 }
 
 - (BOOL)isNSData__
 {
-    return [mockedClass isSubclassOfClass:[NSData class]];
+    return [self.mockedClass isSubclassOfClass:[NSData class]];
 }
 
 - (BOOL)isNSArray__
 {
-    return [mockedClass isSubclassOfClass:[NSArray class]];
+    return [self.mockedClass isSubclassOfClass:[NSArray class]];
 }
 
 @end