second_curtain 0.2.2 → 0.2.3

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

@@ -0,0 +1,187 @@
+#import "ExpectaSupport.h"
+#import "NSValue+Expecta.h"
+#import "NSObject+Expecta.h"
+#import "EXPUnsupportedObject.h"
+#import "EXPFloatTuple.h"
+#import "EXPDoubleTuple.h"
+#import "EXPDefines.h"
+#import <objc/runtime.h>
+
+@interface NSException (ExpectaSenTestFailure)
+
++ (NSException *)failureInFile:(NSString *)filename atLine:(int)lineNumber withDescription:(NSString *)formatString, ...;
+
+@end
+
+@interface NSObject (ExpectaXCTestRecordFailure)
+
+// suppress warning
+- (void)recordFailureWithDescription:(NSString *)description inFile:(NSString *)filename atLine:(NSUInteger)lineNumber expected:(BOOL)expected;
+
+@end
+
+id _EXPObjectify(const char *type, ...) {
+  va_list v;
+  va_start(v, type);
+  id obj = nil;
+  if(strcmp(type, @encode(char)) == 0) {
+    char actual = (char)va_arg(v, int);
+    obj = [NSNumber numberWithChar:actual];
+  } else if(strcmp(type, @encode(_Bool)) == 0) {
+    _Static_assert(sizeof(_Bool) <= sizeof(int), "Expected _Bool to be subject to vararg type promotion");
+    _Bool actual = (_Bool)va_arg(v, int);
+    obj = [NSNumber numberWithBool:actual];
+  } else if(strcmp(type, @encode(double)) == 0) {
+    double actual = (double)va_arg(v, double);
+    obj = [NSNumber numberWithDouble:actual];
+  } else if(strcmp(type, @encode(float)) == 0) {
+    float actual = (float)va_arg(v, double);
+    obj = [NSNumber numberWithFloat:actual];
+  } else if(strcmp(type, @encode(int)) == 0) {
+    int actual = (int)va_arg(v, int);
+    obj = [NSNumber numberWithInt:actual];
+  } else if(strcmp(type, @encode(long)) == 0) {
+    long actual = (long)va_arg(v, long);
+    obj = [NSNumber numberWithLong:actual];
+  } else if(strcmp(type, @encode(long long)) == 0) {
+    long long actual = (long long)va_arg(v, long long);
+    obj = [NSNumber numberWithLongLong:actual];
+  } else if(strcmp(type, @encode(short)) == 0) {
+    short actual = (short)va_arg(v, int);
+    obj = [NSNumber numberWithShort:actual];
+  } else if(strcmp(type, @encode(unsigned char)) == 0) {
+    unsigned char actual = (unsigned char)va_arg(v, unsigned int);
+    obj = [NSNumber numberWithUnsignedChar:actual];
+  } else if(strcmp(type, @encode(unsigned int)) == 0) {
+    unsigned int actual = (int)va_arg(v, unsigned int);
+    obj = [NSNumber numberWithUnsignedInt:actual];
+  } else if(strcmp(type, @encode(unsigned long)) == 0) {
+    unsigned long actual = (unsigned long)va_arg(v, unsigned long);
+    obj = [NSNumber numberWithUnsignedLong:actual];
+  } else if(strcmp(type, @encode(unsigned long long)) == 0) {
+    unsigned long long actual = (unsigned long long)va_arg(v, unsigned long long);
+    obj = [NSNumber numberWithUnsignedLongLong:actual];
+  } else if(strcmp(type, @encode(unsigned short)) == 0) {
+    unsigned short actual = (unsigned short)va_arg(v, unsigned int);
+    obj = [NSNumber numberWithUnsignedShort:actual];
+  } else if(strstr(type, @encode(EXPBasicBlock)) != NULL) {
+      // @encode(EXPBasicBlock) returns @? as of clang 4.1.
+      // This condition must occur before the test for id/class type,
+      // otherwise blocks will be treated as vanilla objects.
+      id actual = va_arg(v, EXPBasicBlock);
+      obj = [[actual copy] autorelease];
+  } else if((strstr(type, @encode(id)) != NULL) || (strstr(type, @encode(Class)) != 0)) {
+    id actual = va_arg(v, id);
+    obj = actual;
+  } else if(strcmp(type, @encode(__typeof__(nil))) == 0) {
+    obj = nil;
+  } else if(strstr(type, "ff}{") != NULL) { //TODO: of course this only works for a 2x2 e.g. CGRect
+    obj = [[[EXPFloatTuple alloc] initWithFloatValues:(float *)va_arg(v, float[4]) size:4] autorelease];
+  } else if(strstr(type, "=ff}") != NULL) {
+    obj = [[[EXPFloatTuple alloc] initWithFloatValues:(float *)va_arg(v, float[2]) size:2] autorelease];
+  } else if(strstr(type, "=ffff}") != NULL) {
+    obj = [[[EXPFloatTuple alloc] initWithFloatValues:(float *)va_arg(v, float[4]) size:4] autorelease];
+  } else if(strstr(type, "dd}{") != NULL) { //TODO: same here
+    obj = [[[EXPDoubleTuple alloc] initWithDoubleValues:(double *)va_arg(v, double[4]) size:4] autorelease];
+  } else if(strstr(type, "=dd}") != NULL) {
+    obj = [[[EXPDoubleTuple alloc] initWithDoubleValues:(double *)va_arg(v, double[2]) size:2] autorelease];
+  } else if(strstr(type, "=dddd}") != NULL) {
+    obj = [[[EXPDoubleTuple alloc] initWithDoubleValues:(double *)va_arg(v, double[4]) size:4] autorelease];
+  } else if(type[0] == '{') {
+    EXPUnsupportedObject *actual = [[[EXPUnsupportedObject alloc] initWithType:@"struct"] autorelease];
+    obj = actual;
+  } else if(type[0] == '(') {
+    EXPUnsupportedObject *actual = [[[EXPUnsupportedObject alloc] initWithType:@"union"] autorelease];
+    obj = actual;
+  } else {
+    void *actual = va_arg(v, void *);
+    obj = (actual == NULL ? nil :[NSValue valueWithPointer:actual]);
+  }
+  if([obj isKindOfClass:[NSValue class]] && ![obj isKindOfClass:[NSNumber class]]) {
+    [(NSValue *)obj set_EXP_objCType:type];
+  }
+  va_end(v);
+  return obj;
+}
+
+EXPExpect *_EXP_expect(id testCase, int lineNumber, const char *fileName, EXPIdBlock actualBlock) {
+  return [EXPExpect expectWithActualBlock:actualBlock testCase:testCase lineNumber:lineNumber fileName:fileName];
+}
+
+void EXPFail(id testCase, int lineNumber, const char *fileName, NSString *message) {
+  NSLog(@"%s:%d %@", fileName, lineNumber, message);
+  NSString *reason = [NSString stringWithFormat:@"%s:%d %@", fileName, lineNumber, message];
+  NSException *exception = [NSException exceptionWithName:@"Expecta Error" reason:reason userInfo:nil];
+
+  if(testCase && [testCase respondsToSelector:@selector(failWithException:)]) {
+    if([[(Class)objc_getMetaClass("NSException") class] instancesRespondToSelector:@selector(failureInFile:atLine:withDescription:)]) {
+      exception = [NSException failureInFile:[NSString stringWithUTF8String:fileName] atLine:lineNumber withDescription:message];
+    }
+    [testCase failWithException:exception];
+  } else if(testCase && [testCase respondsToSelector:@selector(recordFailureWithDescription:inFile:atLine:expected:)]){
+      [testCase recordFailureWithDescription:message
+                                      inFile:[NSString stringWithUTF8String:fileName]
+                                      atLine:lineNumber
+                                    expected:NO];
+  } else {
+    [exception raise];
+  }
+}
+
+NSString *EXPDescribeObject(id obj) {
+  if(obj == nil) {
+    return @"nil/null";
+  } else if([obj isKindOfClass:[NSValue class]] && ![obj isKindOfClass:[NSNumber class]]) {
+    const char *type = [(NSValue *)obj _EXP_objCType];
+    if(type) {
+      if(strcmp(type, @encode(SEL)) == 0) {
+        return [NSString stringWithFormat:@"@selector(%@)", NSStringFromSelector([obj pointerValue])];
+      } else if(strcmp(type, @encode(Class)) == 0) {
+        return NSStringFromClass([obj pointerValue]);
+      }
+    }
+  }
+  NSString *description = [obj description];
+  if([obj isKindOfClass:[NSArray class]]) {
+    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:[obj count]];
+    for(id o in obj) {
+      [arr addObject:EXPDescribeObject(o)];
+    }
+    description = [NSString stringWithFormat:@"(%@)", [arr componentsJoinedByString:@", "]];
+  } else if([obj isKindOfClass:[NSSet class]] || [obj isKindOfClass:[NSOrderedSet class]]) {
+    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:[obj count]];
+    for(id o in obj) {
+      [arr addObject:EXPDescribeObject(o)];
+    }
+    description = [NSString stringWithFormat:@"{(%@)}", [arr componentsJoinedByString:@", "]];
+  } else if([obj isKindOfClass:[NSDictionary class]]) {
+    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:[obj count]];
+    for(id k in obj) {
+      id v = [obj objectForKey:k];
+      [arr addObject:[NSString stringWithFormat:@"%@ = %@;",EXPDescribeObject(k), EXPDescribeObject(v)]];
+    }
+    description = [NSString stringWithFormat:@"{%@}", [arr componentsJoinedByString:@" "]];
+  } else if([obj isKindOfClass:[NSAttributedString class]]) {
+    description = [obj string];
+  } else {
+    description = [description stringByReplacingOccurrencesOfString:@"\n" withString:@"\\n"];
+  }
+  return description;
+}
+
+void EXP_prerequisite(EXPBoolBlock block) {
+  [[[[NSThread currentThread] threadDictionary] objectForKey:@"EXP_currentMatcher"] setPrerequisiteBlock:block];
+}
+
+void EXP_match(EXPBoolBlock block) {
+  [[[[NSThread currentThread] threadDictionary] objectForKey:@"EXP_currentMatcher"] setMatchBlock:block];
+}
+
+void EXP_failureMessageForTo(EXPStringBlock block) {
+  [[[[NSThread currentThread] threadDictionary] objectForKey:@"EXP_currentMatcher"] setFailureMessageForToBlock:block];
+}
+
+void EXP_failureMessageForNotTo(EXPStringBlock block) {
+  [[[[NSThread currentThread] threadDictionary] objectForKey:@"EXP_currentMatcher"] setFailureMessageForNotToBlock:block];
+}
+

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

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+@interface NSObject (Expecta)
+
+#ifdef USE_XCTEST
+- (void)recordFailureWithDescription:(NSString *)description
+                              inFile:(NSString *)filename
+                              atLine:(NSUInteger)lineNumber
+                            expected:(BOOL)expected;
+#else
+- (void)failWithException:(NSException *)exception;
+#endif
+
+@end

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

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+@interface NSValue (Expecta)
+
+- (const char *)_EXP_objCType;
+- (void)set_EXP_objCType:(const char *)_EXP_objCType;
+
+@end

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

@@ -0,0 +1,21 @@
+#import "NSValue+Expecta.h"
+#import <objc/runtime.h>
+#import "Expecta.h"
+
+EXPFixCategoriesBug(NSValue_Expecta);
+
+@implementation NSValue (Expecta)
+
+static char _EXP_typeKey;
+
+- (const char *)_EXP_objCType {
+  return [(NSString *)objc_getAssociatedObject(self, &_EXP_typeKey) cStringUsingEncoding:NSASCIIStringEncoding];
+}
+
+- (void)set_EXP_objCType:(const char *)_EXP_objCType {
+  objc_setAssociatedObject(self, &_EXP_typeKey,
+                           [NSString stringWithCString:_EXP_objCType encoding:NSASCIIStringEncoding],
+                           OBJC_ASSOCIATION_COPY_NONATOMIC);
+}
+
+@end

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

@@ -0,0 +1,4 @@
+#import <Foundation/Foundation.h>
+
+BOOL EXPIsValuePointer(NSValue *value);
+BOOL EXPIsNumberFloat(NSNumber *number);

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

@@ -0,0 +1,9 @@
+#import "EXPMatcherHelpers.h"
+
+BOOL EXPIsValuePointer(NSValue *value) {
+  return [value objCType][0] == @encode(void *)[0];
+}
+
+BOOL EXPIsNumberFloat(NSNumber *number) {
+  return strcmp([number objCType], @encode(float)) == 0;
+}

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beCloseTo.h

@@ -0,0 +1,7 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beCloseToWithin, (id expected, id within));
+EXPMatcherInterface(beCloseToWithin, (id expected, id within));
+
+#define beCloseTo(expected) _beCloseToWithin(EXPObjectify((expected)), nil)
+#define beCloseToWithin(expected, range) _beCloseToWithin(EXPObjectify((expected)), EXPObjectify((range)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beCloseTo.m

@@ -0,0 +1,49 @@
+#import "EXPMatchers+beCloseTo.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_beCloseToWithin, (id expected, id within)) {
+  prerequisite(^BOOL{
+    return [actual isKindOfClass:[NSNumber class]] &&
+		[expected isKindOfClass:[NSNumber class]] &&
+		([within isKindOfClass:[NSNumber class]] || (within == nil));
+  });
+
+  match(^BOOL{
+		double actualValue = [actual doubleValue];
+		double expectedValue = [expected doubleValue];
+
+		if (within != nil) {
+			double withinValue = [within doubleValue];
+			double lowerBound = expectedValue - withinValue;
+			double upperBound = expectedValue + withinValue;
+			return (actualValue >= lowerBound) && (actualValue <= upperBound);
+		} else {
+			double diff = fabs(actualValue - expectedValue);
+			actualValue = fabs(actualValue);
+			expectedValue = fabs(expectedValue);
+			double largest = (expectedValue > actualValue) ? expectedValue : actualValue;
+			return (diff <= largest * FLT_EPSILON);
+		}
+  });
+
+  failureMessageForTo(^NSString *{
+    if (within) {
+      return [NSString stringWithFormat:@"expected %@ to be close to %@ within %@",
+              EXPDescribeObject(actual), EXPDescribeObject(expected), EXPDescribeObject(within)];
+    } else {
+      return [NSString stringWithFormat:@"expected %@ to be close to %@",
+              EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    }
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if (within) {
+      return [NSString stringWithFormat:@"expected %@ not to be close to %@ within %@",
+              EXPDescribeObject(actual), EXPDescribeObject(expected), EXPDescribeObject(within)];
+    } else {
+      return [NSString stringWithFormat:@"expected %@ not to be close to %@",
+              EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    }
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beFalsy.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beFalsy, (void));

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beFalsy.m

@@ -0,0 +1,24 @@
+#import "EXPMatchers+beFalsy.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(beFalsy, (void)) {
+  match(^BOOL{
+    if([actual isKindOfClass:[NSNumber class]]) {
+      return ![(NSNumber *)actual boolValue];
+    } else if([actual isKindOfClass:[NSValue class]]) {
+      if(EXPIsValuePointer((NSValue *)actual)) {
+        return ![(NSValue *)actual pointerValue];
+      }
+    }
+    return !actual;
+  });
+
+  failureMessageForTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: a falsy value, got: %@, which is truthy", EXPDescribeObject(actual)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: a non-falsy value, got: %@, which is falsy", EXPDescribeObject(actual)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beGreaterThan.h

@@ -0,0 +1,6 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beGreaterThan, (id expected));
+EXPMatcherInterface(beGreaterThan, (id expected));
+
+#define beGreaterThan(expected) _beGreaterThan(EXPObjectify((expected)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beGreaterThan.m

@@ -0,0 +1,20 @@
+#import "EXPMatchers+beGreaterThan.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_beGreaterThan, (id expected)) {
+    match(^BOOL{
+        if ([actual respondsToSelector:@selector(compare:)]) {
+            return [actual compare:expected] == NSOrderedDescending;
+        }
+        return NO;
+    });
+
+    failureMessageForTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ to be greater than %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+
+    failureMessageForNotTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ not to be greater than %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beGreaterThanOrEqualTo.h

@@ -0,0 +1,6 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beGreaterThanOrEqualTo, (id expected));
+EXPMatcherInterface(beGreaterThanOrEqualTo, (id expected));
+
+#define beGreaterThanOrEqualTo(expected) _beGreaterThanOrEqualTo(EXPObjectify((expected)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beGreaterThanOrEqualTo.m

@@ -0,0 +1,20 @@
+#import "EXPMatchers+beGreaterThanOrEqualTo.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_beGreaterThanOrEqualTo, (id expected)) {
+    match(^BOOL{
+        if ([actual respondsToSelector:@selector(compare:)]) {
+            return [actual compare:expected] != NSOrderedAscending;
+        }
+        return NO;
+    });
+
+    failureMessageForTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ to be greater than or equal to %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+
+    failureMessageForNotTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ not to be greater than or equal to %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beIdenticalTo.h

@@ -0,0 +1,10 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beIdenticalTo, (void *expected));
+EXPMatcherInterface(beIdenticalTo, (void *expected)); // to aid code completion
+
+#if __has_feature(objc_arc)
+#define beIdenticalTo(expected) _beIdenticalTo((__bridge void*)expected)
+#else
+#define beIdenticalTo _beIdenticalTo
+#endif

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beIdenticalTo.m

@@ -0,0 +1,24 @@
+#import "EXPMatchers+equal.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(beIdenticalTo, (void *expected)) {
+  match(^BOOL{
+    if(actual == expected) {
+      return YES;
+    } else if([actual isKindOfClass:[NSValue class]] && EXPIsValuePointer((NSValue *)actual)) {
+      if([(NSValue *)actual pointerValue] == expected) {
+        return YES;
+      }
+    }
+    return NO;
+  });
+
+  failureMessageForTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: <%p>, got: <%p>", expected, actual];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: not <%p>, got: <%p>", expected, actual];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beInTheRangeOf.h

@@ -0,0 +1,6 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beInTheRangeOf, (id expectedLowerBound, id expectedUpperBound));
+EXPMatcherInterface(beInTheRangeOf, (id expectedLowerBound, id expectedUpperBound));
+
+#define beInTheRangeOf(expectedLowerBound, expectedUpperBound) _beInTheRangeOf(EXPObjectify((expectedLowerBound)), EXPObjectify((expectedUpperBound)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beInTheRangeOf.m

@@ -0,0 +1,30 @@
+#import "EXPMatchers+beInTheRangeOf.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_beInTheRangeOf, (id expectedLowerBound, id expectedUpperBound)) {
+    match(^BOOL{
+        if ([actual respondsToSelector:@selector(compare:)]) {
+            NSComparisonResult compareLowerBound = [expectedLowerBound compare: actual];
+            NSComparisonResult compareUpperBound = [expectedUpperBound compare: actual];
+            if (compareLowerBound == NSOrderedSame) {
+                return YES;
+            }
+            if (compareUpperBound == NSOrderedSame) {
+                return YES;
+            }
+            if ((compareLowerBound == NSOrderedAscending) && (compareUpperBound == NSOrderedDescending)) {
+                return YES;
+            }
+        }
+        return NO;
+    });
+
+    failureMessageForTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ to be in the range [%@, %@] (inclusive)", EXPDescribeObject(actual), EXPDescribeObject(expectedLowerBound), EXPDescribeObject(expectedUpperBound)];
+    });
+
+    failureMessageForNotTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ not to be in the range [%@, %@] (inclusive)", EXPDescribeObject(actual), EXPDescribeObject(expectedLowerBound), EXPDescribeObject(expectedUpperBound)];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beInstanceOf.h

@@ -0,0 +1,7 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beInstanceOf, (Class expected));
+
+#define beAnInstanceOf beInstanceOf
+#define beMemberOf beInstanceOf
+#define beAMemberOf beInstanceOf

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beInstanceOf.m

@@ -0,0 +1,27 @@
+#import "EXPMatchers+beInstanceOf.h"
+
+EXPMatcherImplementationBegin(beInstanceOf, (Class expected)) {
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNil = (expected == nil);
+
+  prerequisite(^BOOL{
+    return !(actualIsNil || expectedIsNil);
+  });
+
+  match(^BOOL{
+    return [actual isMemberOfClass:expected];
+  });
+
+  failureMessageForTo(^NSString *{
+    if(actualIsNil) return @"the actual value is nil/null";
+    if(expectedIsNil) return @"the expected value is nil/null";
+    return [NSString stringWithFormat:@"expected: an instance of %@, got: an instance of %@", [expected class], [actual class]];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(actualIsNil) return @"the actual value is nil/null";
+    if(expectedIsNil) return @"the expected value is nil/null";
+    return [NSString stringWithFormat:@"expected: not an instance of %@, got: an instance of %@", [expected class], [actual class]];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beKindOf.h

@@ -0,0 +1,5 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beKindOf, (Class expected));
+
+#define beAKindOf beKindOf

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beKindOf.m

@@ -0,0 +1,27 @@
+#import "EXPMatchers+beKindOf.h"
+
+EXPMatcherImplementationBegin(beKindOf, (Class expected)) {
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNil = (expected == nil);
+
+  prerequisite(^BOOL{
+    return !(actualIsNil || expectedIsNil);
+  });
+
+  match(^BOOL{
+    return [actual isKindOfClass:expected];
+  });
+
+  failureMessageForTo(^NSString *{
+    if(actualIsNil) return @"the actual value is nil/null";
+    if(expectedIsNil) return @"the expected value is nil/null";
+    return [NSString stringWithFormat:@"expected: a kind of %@, got: an instance of %@, which is not a kind of %@", [expected class], [actual class], [expected class]];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(actualIsNil) return @"the actual value is nil/null";
+    if(expectedIsNil) return @"the expected value is nil/null";
+    return [NSString stringWithFormat:@"expected: not a kind of %@, got: an instance of %@, which is a kind of %@", [expected class], [actual class], [expected class]];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beLessThan.h

@@ -0,0 +1,6 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beLessThan, (id expected));
+EXPMatcherInterface(beLessThan, (id expected));
+
+#define beLessThan(expected) _beLessThan(EXPObjectify((expected)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beLessThan.m

@@ -0,0 +1,20 @@
+#import "EXPMatchers+beLessThan.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_beLessThan, (id expected)) {
+    match(^BOOL{
+        if ([actual respondsToSelector:@selector(compare:)]) {
+            return [actual compare:expected] == NSOrderedAscending;
+        }
+        return NO;
+    });
+
+    failureMessageForTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ to be less than %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+
+    failureMessageForNotTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ not to be less than %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beLessThanOrEqualTo.h

@@ -0,0 +1,6 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(_beLessThanOrEqualTo, (id expected));
+EXPMatcherInterface(beLessThanOrEqualTo, (id expected));
+
+#define beLessThanOrEqualTo(expected) _beLessThanOrEqualTo(EXPObjectify((expected)))

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beLessThanOrEqualTo.m

@@ -0,0 +1,20 @@
+#import "EXPMatchers+beLessThanOrEqualTo.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(_beLessThanOrEqualTo, (id expected)) {
+    match(^BOOL{
+        if ([actual respondsToSelector:@selector(compare:)]) {
+            return [actual compare:expected] != NSOrderedDescending;
+        }
+        return NO;
+    });
+
+    failureMessageForTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ to be less than or equal to %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+
+    failureMessageForNotTo(^NSString *{
+        return [NSString stringWithFormat:@"expected: %@ not to be less than or equal to %@", EXPDescribeObject(actual), EXPDescribeObject(expected)];
+    });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beNil.h

@@ -0,0 +1,5 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beNil, (void));
+
+#define beNull beNil

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beNil.m

@@ -0,0 +1,16 @@
+#import "EXPMatchers+beNil.h"
+
+EXPMatcherImplementationBegin(beNil, (void)) {
+  match(^BOOL{
+    return actual == nil;
+  });
+
+  failureMessageForTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: nil/null, got: %@", EXPDescribeObject(actual)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: not nil/null, got: %@", EXPDescribeObject(actual)];
+  });
+}
+EXPMatcherImplementationEnd

data/Demo/Pods/Expecta/src/matchers/EXPMatchers+beSubclassOf.h

@@ -0,0 +1,5 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(beSubclassOf, (Class expected));
+
+#define beASubclassOf beSubclassOf