second_curtain 0.2.2 → 0.2.3

data/Demo/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/Demo/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/Demo/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

data/Demo/Pods/Expecta/src/EXPFloatTuple.h

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

data/Demo/Pods/Expecta/src/EXPFloatTuple.m

@@ -0,0 +1,42 @@
+#import "EXPFloatTuple.h"
+
+@implementation EXPFloatTuple
+
+@synthesize values = _values, size = _size;
+
+- (id)initWithFloatValues:(float *)values size:(size_t)size {
+    if ((self = [super init])) {
+        self.values = malloc(sizeof(float) * size);
+        memcpy(self.values, values, sizeof(float) * size);
+        self.size = size;
+    }
+    return self;
+}
+
+- (void)dealloc {
+    free(self.values);
+    [super dealloc];
+}
+
+- (BOOL)isEqual:(id)object {
+    if (![object isKindOfClass:[EXPFloatTuple class]]) return NO;
+    EXPFloatTuple *other = (EXPFloatTuple *)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:@"Float tuple: {%f, %f}", self.values[0], self.values[1]];
+    } else if (self.size == 4) {
+        return [NSString stringWithFormat:@"Float tuple: {%f, %f, %f, %f}", self.values[0], self.values[1], self.values[2], self.values[3]];
+    }
+    return [NSString stringWithFormat:@"Float tuple of unexpected size %zd, sadly", self.size];
+}
+
+@end

data/Demo/Pods/Expecta/src/EXPMatcher.h

@@ -0,0 +1,20 @@
+//
+//  EXPMatcher.h
+//  Expecta
+//
+//  Created by Luke Redpath on 26/03/2012.
+//  Copyright (c) 2012 Peter Jihoon Kim. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@protocol EXPMatcher <NSObject>
+
+- (BOOL)matches:(id)actual;
+
+@optional
+- (BOOL)meetsPrerequesiteFor:(id)actual;
+- (NSString *)failureMessageForTo:(id)actual;
+- (NSString *)failureMessageForNotTo:(id)actual;
+
+@end

data/Demo/Pods/Expecta/src/EXPUnsupportedObject.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+@interface EXPUnsupportedObject : NSObject {
+  NSString *_type;
+}
+
+@property (nonatomic, retain) NSString *type;
+
+- (id)initWithType:(NSString *)type;
+
+@end

data/Demo/Pods/Expecta/src/EXPUnsupportedObject.m

@@ -0,0 +1,20 @@
+#import "EXPUnsupportedObject.h"
+
+@implementation EXPUnsupportedObject
+
+@synthesize type=_type;
+
+- (id)initWithType:(NSString *)type {
+  self = [super init];
+  if(self) {
+    self.type = type;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  self.type = nil;
+  [super dealloc];
+}
+
+@end

data/Demo/Pods/Expecta/src/Expecta.h

@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+#import "ExpectaSupport.h"
+
+#define EXPObjectify(value) _EXPObjectify(@encode(__typeof__((value))), (value))
+
+#define EXP_expect(actual) _EXP_expect(self, __LINE__, __FILE__, ^id{ return EXPObjectify((actual)); })
+
+#define EXPMatcherInterface(matcherName, matcherArguments) _EXPMatcherInterface(matcherName, matcherArguments)
+#define EXPMatcherImplementationBegin(matcherName, matcherArguments) _EXPMatcherImplementationBegin(matcherName, matcherArguments)
+#define EXPMatcherImplementationEnd _EXPMatcherImplementationEnd
+
+#import "EXPMatchers.h"
+
+#ifdef EXP_SHORTHAND
+#  define expect(...) EXP_expect((__VA_ARGS__))
+#endif
+
+#ifdef EXP_OLD_SYNTAX
+#  import "EXPBackwardCompatibility.h"
+#endif
+
+@interface Expecta : NSObject
+
++ (NSTimeInterval)asynchronousTestTimeout;
++ (void)setAsynchronousTestTimeout:(NSTimeInterval)timeout;
+
+@end

data/Demo/Pods/Expecta/src/Expecta.m

@@ -0,0 +1,15 @@
+#import "Expecta.h"
+
+@implementation Expecta
+
+static NSTimeInterval _asynchronousTestTimeout = 1.0;
+
++ (NSTimeInterval)asynchronousTestTimeout {
+  return _asynchronousTestTimeout;
+}
+
++ (void)setAsynchronousTestTimeout:(NSTimeInterval)timeout {
+  _asynchronousTestTimeout = timeout;
+}
+
+@end

data/Demo/Pods/Expecta/src/ExpectaSupport.h

@@ -0,0 +1,64 @@
+#import "EXPExpect.h"
+#import "EXPBlockDefinedMatcher.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+id _EXPObjectify(const char *type, ...);
+EXPExpect *_EXP_expect(id testCase, int lineNumber, const char *fileName, EXPIdBlock actualBlock);
+
+void EXPFail(id testCase, int lineNumber, const char *fileName, NSString *message);
+NSString *EXPDescribeObject(id obj);
+
+void EXP_prerequisite(EXPBoolBlock block);
+void EXP_match(EXPBoolBlock block);
+void EXP_failureMessageForTo(EXPStringBlock block);
+void EXP_failureMessageForNotTo(EXPStringBlock block);
+
+#if __has_feature(objc_arc)
+#define _EXP_release(x)
+#define _EXP_autorelease(x) (x)
+
+#else
+#define _EXP_release(x) [x release]
+#define _EXP_autorelease(x) [x autorelease]
+#endif
+
+// workaround for the categories bug: http://developer.apple.com/library/mac/#qa/qa1490/_index.html
+#define EXPFixCategoriesBug(name) \
+__attribute__((constructor)) static void EXPFixCategoriesBug##name() {}
+
+#define _EXPMatcherInterface(matcherName, matcherArguments) \
+@interface EXPExpect (matcherName##Matcher) \
+@property (nonatomic, readonly) void(^ matcherName) matcherArguments; \
+@end
+
+#define _EXPMatcherImplementationBegin(matcherName, matcherArguments) \
+EXPFixCategoriesBug(EXPMatcher##matcherName##Matcher); \
+@implementation EXPExpect (matcherName##Matcher) \
+@dynamic matcherName;\
+- (void(^) matcherArguments) matcherName { \
+  EXPBlockDefinedMatcher *matcher = [[EXPBlockDefinedMatcher alloc] init]; \
+  [[[NSThread currentThread] threadDictionary] setObject:matcher forKey:@"EXP_currentMatcher"]; \
+  __block id actual = self.actual; \
+  __block void (^prerequisite)(EXPBoolBlock block) = ^(EXPBoolBlock block) { EXP_prerequisite(block); }; \
+  __block void (^match)(EXPBoolBlock block) = ^(EXPBoolBlock block) { EXP_match(block); }; \
+  __block void (^failureMessageForTo)(EXPStringBlock block) = ^(EXPStringBlock block) { EXP_failureMessageForTo(block); }; \
+  __block void (^failureMessageForNotTo)(EXPStringBlock block) = ^(EXPStringBlock block) { EXP_failureMessageForNotTo(block); }; \
+  prerequisite(nil); match(nil); failureMessageForTo(nil); failureMessageForNotTo(nil); \
+  void (^matcherBlock) matcherArguments = [^ matcherArguments { \
+    {
+
+#define _EXPMatcherImplementationEnd \
+    } \
+    [self applyMatcher:matcher to:&actual]; \
+  } copy]; \
+  _EXP_release(matcher); \
+  return _EXP_autorelease(matcherBlock); \
+} \
+@end
+
+#ifdef __cplusplus
+}
+#endif