cocoapods-deintegrate 0.1.1 → 0.2.0

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPBackwardCompatibility.h

@@ -0,0 +1,42 @@
+#import "EXPExpect.h"
+
+@interface EXPExpect (BackwardCompatiblity)
+
+@property(nonatomic, readonly) EXPExpect *Not;
+@property(nonatomic, readonly) EXPExpect *isGoing;
+@property(nonatomic, readonly) EXPExpect *isNotGoing;
+
+@end
+
+#define toBeFalsy                     beFalsy
+#define toBeGreaterThan               beGreaterThan
+#define toBeGreaterThanOrEqualTo      beGreaterThanOrEqualTo
+#define toBeIdenticalTo               beIdenticalTo
+#define toBeInTheRangeOf              beInTheRangeOf
+#define toBeInstanceOf                beInstanceOf
+#define toBeAnInstanceOf              beInstanceOf
+#define toBeMemberOf                  beInstanceOf
+#define toBeAMemberOf                 beInstanceOf
+#define toBeKindOf                    beKindOf
+#define toBeAKindOf                   beKindOf
+#define toBeLessThan                  beLessThan
+#define toBeLessThanOrEqualTo         beLessThanOrEqualTo
+#define toBeNil                       beNil
+#define toBeNull                      beNil
+#define toBeSubclassOf                beSubclassOf
+#define toBeASubclassOf               beSubclassOf
+#define toBeTruthy                    beTruthy
+#define toBeFalsy                     beFalsy
+#define toContain                     contain
+#define toEqual                       equal
+#define toBeCloseTo                   beCloseTo
+#define toBeCloseToWithin             beCloseToWithin
+#define toHaveCount                   haveCountOf
+#define toHaveCountOf                 haveCountOf
+#define toHaveACountOf                haveCountOf
+#define toHaveLength                  haveCountOf
+#define toHaveLengthOf                haveCountOf
+#define toHaveALengthOf               haveCountOf
+#define toBeEmpty                     beEmpty
+#define toRaise                       raise
+#define toRaiseAny                    raiseAny

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPBackwardCompatibility.m

@@ -0,0 +1,17 @@
+#import "EXPBackwardCompatibility.h"
+
+@implementation EXPExpect (BackwardCompatiblity)
+
+- (EXPExpect *)Not {
+  return self.toNot;
+}
+
+- (EXPExpect *)isGoing {
+  return self.will;
+}
+
+- (EXPExpect *)isNotGoing {
+  return self.willNot;
+}
+
+@end

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPBlockDefinedMatcher.h

@@ -0,0 +1,25 @@
+//
+//  EXPRuntimeMatcher.h
+//  Expecta
+//
+//  Created by Luke Redpath on 26/03/2012.
+//  Copyright (c) 2012 Peter Jihoon Kim. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "EXPMatcher.h"
+#import "EXPDefines.h"
+
+@interface EXPBlockDefinedMatcher : NSObject <EXPMatcher> {
+  EXPBoolBlock prerequisiteBlock;
+  EXPBoolBlock matchBlock;
+  EXPStringBlock failureMessageForToBlock;
+  EXPStringBlock failureMessageForNotToBlock;
+}
+
+@property(nonatomic, copy) EXPBoolBlock prerequisiteBlock;
+@property(nonatomic, copy) EXPBoolBlock matchBlock;
+@property(nonatomic, copy) EXPStringBlock failureMessageForToBlock;
+@property(nonatomic, copy) EXPStringBlock failureMessageForNotToBlock;
+
+@end

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPBlockDefinedMatcher.m

@@ -0,0 +1,60 @@
+//
+//  EXPRuntimeMatcher.m
+//  Expecta
+//
+//  Created by Luke Redpath on 26/03/2012.
+//  Copyright (c) 2012 Peter Jihoon Kim. All rights reserved.
+//
+
+#import "EXPBlockDefinedMatcher.h"
+
+@implementation EXPBlockDefinedMatcher
+
+- (void)dealloc
+{
+    self.prerequisiteBlock = nil;
+    self.matchBlock = nil;
+    self.failureMessageForToBlock = nil;
+    self.failureMessageForNotToBlock = nil;
+    
+    [super dealloc];
+}
+
+@synthesize prerequisiteBlock;
+@synthesize matchBlock;
+@synthesize failureMessageForToBlock;
+@synthesize failureMessageForNotToBlock;
+
+- (BOOL)meetsPrerequesiteFor:(id)actual
+{
+  if (self.prerequisiteBlock) {
+    return self.prerequisiteBlock();
+  }
+  return YES;
+}
+
+- (BOOL)matches:(id)actual
+{
+  if (self.matchBlock) {
+    return self.matchBlock();
+  }
+  return YES;
+}
+
+- (NSString *)failureMessageForTo:(id)actual
+{
+  if (self.failureMessageForToBlock) {
+    return self.failureMessageForToBlock();
+  }
+  return nil;
+}
+
+- (NSString *)failureMessageForNotTo:(id)actual
+{
+  if (self.failureMessageForNotToBlock) {
+    return self.failureMessageForNotToBlock();
+  }
+  return nil;
+}
+
+@end

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPDefines.h

@@ -0,0 +1,17 @@
+//
+//  EXPDefines.h
+//  Expecta
+//
+//  Created by Luke Redpath on 26/03/2012.
+//  Copyright (c) 2012 Peter Jihoon Kim. All rights reserved.
+//
+
+#ifndef Expecta_EXPDefines_h
+#define Expecta_EXPDefines_h
+
+typedef void (^EXPBasicBlock)();
+typedef id (^EXPIdBlock)();
+typedef BOOL (^EXPBoolBlock)();
+typedef NSString *(^EXPStringBlock)();
+
+#endif

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPDoubleTuple.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+@interface EXPDoubleTuple : NSObject {
+    double *_values;
+    size_t _size;
+}
+
+@property (nonatomic, assign) double *values;
+@property (nonatomic, assign) size_t size;
+
+- (id)initWithDoubleValues:(double *)values size:(size_t)size;
+
+@end

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPDoubleTuple.m

@@ -0,0 +1,42 @@
+#import "EXPDoubleTuple.h"
+
+@implementation EXPDoubleTuple
+
+@synthesize values = _values, size = _size;
+
+- (id)initWithDoubleValues:(double *)values size:(size_t)size {
+    if ((self = [super init])) {
+        self.values = malloc(sizeof(double) * size);
+        memcpy(self.values, values, sizeof(double) * size);
+        self.size = size;
+    }
+    return self;
+}
+
+- (void)dealloc {
+    free(self.values);
+    [super dealloc];
+}
+
+- (BOOL)isEqual:(id)object {
+    if (![object isKindOfClass:[EXPDoubleTuple class]]) return NO;
+    EXPDoubleTuple *other = (EXPDoubleTuple *)object;
+    if (self.size == other.size) {
+        for (int i = 0; i < self.size; ++i) {
+            if (self.values[i] != other.values[i]) return NO;
+        }
+        return YES;
+    }
+    return NO;
+}
+
+- (NSString *)description {
+    if (self.size == 2) {
+        return [NSString stringWithFormat:@"Double tuple: {%f, %f}", self.values[0], self.values[1]];
+    } else if (self.size == 4) {
+        return [NSString stringWithFormat:@"Double tuple: {%f, %f, %f, %f}", self.values[0], self.values[1], self.values[2], self.values[3]];
+    }
+    return [NSString stringWithFormat:@"Double tuple of unexpected size %zd, sadly", self.size];
+}
+
+@end

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPExpect.h

@@ -0,0 +1,45 @@
+#import <Foundation/Foundation.h>
+#import "EXPMatcher.h"
+#import "EXPDefines.h"
+
+@interface EXPExpect : NSObject {
+  EXPIdBlock _actualBlock;
+  id _testCase;
+  int _lineNumber;
+  char *_fileName;
+  BOOL _negative;
+  BOOL _asynchronous;
+  NSTimeInterval _timeout;
+}
+
+@property(nonatomic, copy) EXPIdBlock actualBlock;
+@property(nonatomic, readonly) id actual;
+@property(nonatomic, assign) id testCase;
+@property(nonatomic) int lineNumber;
+@property(nonatomic) const char *fileName;
+@property(nonatomic) BOOL negative;
+@property(nonatomic) BOOL asynchronous;
+@property(nonatomic) NSTimeInterval timeout;
+
+@property(nonatomic, readonly) EXPExpect *to;
+@property(nonatomic, readonly) EXPExpect *toNot;
+@property(nonatomic, readonly) EXPExpect *notTo;
+@property(nonatomic, readonly) EXPExpect *will;
+@property(nonatomic, readonly) EXPExpect *willNot;
+@property(nonatomic, readonly) EXPExpect *(^after)(NSTimeInterval timeInterval);
+
+- (id)initWithActualBlock:(id)actualBlock testCase:(id)testCase lineNumber:(int)lineNumber fileName:(const char *)fileName;
++ (EXPExpect *)expectWithActualBlock:(id)actualBlock testCase:(id)testCase lineNumber:(int)lineNumber fileName:(const char *)fileName;
+
+- (void)applyMatcher:(id<EXPMatcher>)matcher;
+- (void)applyMatcher:(id<EXPMatcher>)matcher to:(NSObject **)actual;
+
+@end
+
+@interface EXPDynamicPredicateMatcher : NSObject <EXPMatcher> {
+  EXPExpect *_expectation;
+  SEL _selector;
+}
+- (id)initWithExpectation:(EXPExpect *)expectation selector:(SEL)selector;
+- (void (^)(void))dispatch;
+@end

data/spec/fixtures/Project/StaticLibraries/Pods/Expecta/src/EXPExpect.m

@@ -0,0 +1,214 @@
+#import "EXPExpect.h"
+#import "NSObject+Expecta.h"
+#import "Expecta.h"
+#import "EXPUnsupportedObject.h"
+#import "EXPMatcher.h"
+#import "EXPBlockDefinedMatcher.h"
+#import <libkern/OSAtomic.h>
+
+@implementation EXPExpect
+
+@dynamic
+  actual,
+  to,
+  toNot,
+  notTo,
+  will,
+  willNot,
+  after;
+
+@synthesize
+  actualBlock=_actualBlock,
+  testCase=_testCase,
+  negative=_negative,
+  asynchronous=_asynchronous,
+  timeout=_timeout,
+  lineNumber=_lineNumber,
+  fileName=_fileName;
+
+- (id)initWithActualBlock:(id)actualBlock testCase:(id)testCase lineNumber:(int)lineNumber fileName:(const char *)fileName {
+  self = [super init];
+  if(self) {
+    self.actualBlock = actualBlock;
+    self.testCase = testCase;
+    self.negative = NO;
+    self.asynchronous = NO;
+    self.timeout = [Expecta asynchronousTestTimeout];
+    self.lineNumber = lineNumber;
+    self.fileName = fileName;
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  self.actualBlock = nil;
+  [super dealloc];
+}
+
++ (EXPExpect *)expectWithActualBlock:(id)actualBlock testCase:(id)testCase lineNumber:(int)lineNumber fileName:(const char *)fileName {
+  return [[[EXPExpect alloc] initWithActualBlock:actualBlock testCase:(id)testCase lineNumber:lineNumber fileName:fileName] autorelease];
+}
+
+#pragma mark -
+
+- (EXPExpect *)to {
+  return self;
+}
+
+- (EXPExpect *)toNot {
+  self.negative = !self.negative;
+  return self;
+}
+
+- (EXPExpect *)notTo {
+  return [self toNot];
+}
+
+- (EXPExpect *)will {
+  self.asynchronous = YES;
+  return self;
+}
+
+- (EXPExpect *)willNot {
+  return self.will.toNot;
+}
+
+- (EXPExpect *(^)(NSTimeInterval))after
+{
+  EXPExpect * (^block)(NSTimeInterval) = [^EXPExpect *(NSTimeInterval timeout) {
+    self.asynchronous = YES;
+    self.timeout = timeout;
+    return self;
+  } copy];
+
+  return [block autorelease];
+}
+
+#pragma mark -
+
+- (id)actual {
+  if(self.actualBlock) {
+    return self.actualBlock();
+  }
+  return nil;
+}
+
+- (void)applyMatcher:(id<EXPMatcher>)matcher
+{
+  id actual = [self actual];
+  [self applyMatcher:matcher to:&actual];
+}
+
+- (void)applyMatcher:(id<EXPMatcher>)matcher to:(NSObject **)actual {
+  if([*actual isKindOfClass:[EXPUnsupportedObject class]]) {
+    EXPFail(self.testCase, self.lineNumber, self.fileName,
+            [NSString stringWithFormat:@"expecting a %@ is not supported", ((EXPUnsupportedObject *)*actual).type]);
+  } else {
+    BOOL failed = NO;
+    if([matcher respondsToSelector:@selector(meetsPrerequesiteFor:)] &&
+       ![matcher meetsPrerequesiteFor:*actual]) {
+      failed = YES;
+    } else {
+      BOOL matchResult = NO;
+      if(self.asynchronous) {
+        NSTimeInterval timeOut = self.timeout;
+        NSDate *expiryDate = [NSDate dateWithTimeIntervalSinceNow:timeOut];
+        while(1) {
+          matchResult = [matcher matches:*actual];
+          failed = self.negative ? matchResult : !matchResult;
+          if(!failed || ([(NSDate *)[NSDate date] compare:expiryDate] == NSOrderedDescending)) {
+            break;
+          }
+          [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+          OSMemoryBarrier();
+          *actual = self.actual;
+        }
+      } else {
+        matchResult = [matcher matches:*actual];
+      }
+      failed = self.negative ? matchResult : !matchResult;
+    }
+    if(failed) {
+      NSString *message = nil;
+
+      if(self.negative) {
+        if ([matcher respondsToSelector:@selector(failureMessageForNotTo:)]) {
+          message = [matcher failureMessageForNotTo:*actual];
+        }
+      } else {
+        if ([matcher respondsToSelector:@selector(failureMessageForTo:)]) {
+          message = [matcher failureMessageForTo:*actual];
+        }
+      }
+      if (message == nil) {
+        message = @"Match Failed.";
+      }
+
+      EXPFail(self.testCase, self.lineNumber, self.fileName, message);
+    }
+  }
+  self.negative = NO;
+}
+
+#pragma mark - Dynamic predicate dispatch
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
+{
+  if ([self.actual respondsToSelector:aSelector]) {
+    return [self.actual methodSignatureForSelector:aSelector];
+  }
+  return [super methodSignatureForSelector:aSelector];
+}
+
+- (void)forwardInvocation:(NSInvocation *)anInvocation
+{
+  if ([self.actual respondsToSelector:anInvocation.selector]) {
+    EXPDynamicPredicateMatcher *matcher = [[EXPDynamicPredicateMatcher alloc] initWithExpectation:self selector:anInvocation.selector];
+    [anInvocation setSelector:@selector(dispatch)];
+    [anInvocation invokeWithTarget:matcher];
+    [matcher release];
+  }
+  else {
+    [super forwardInvocation:anInvocation];
+  }
+}
+
+@end
+
+@implementation EXPDynamicPredicateMatcher
+
+- (id)initWithExpectation:(EXPExpect *)expectation selector:(SEL)selector
+{
+  if ((self = [super init])) {
+    _expectation = expectation;
+    _selector = selector;
+  }
+  return self;
+}
+
+- (BOOL)matches:(id)actual
+{
+  return (BOOL)[actual performSelector:_selector];
+}
+
+- (NSString *)failureMessageForTo:(id)actual
+{
+  return [NSString stringWithFormat:@"expected %@ to be true", NSStringFromSelector(_selector)];
+}
+
+- (NSString *)failureMessageForNotTo:(id)actual
+{
+  return [NSString stringWithFormat:@"expected %@ to be false", NSStringFromSelector(_selector)];
+}
+
+- (void (^)(void))dispatch
+{
+  __block id blockExpectation = _expectation;
+
+  return [[^{
+    [blockExpectation applyMatcher:self];
+  } copy] autorelease];
+}
+
+@end