remove /Pods/ from .gitignore

.gitignore

@@ -13,7 +13,6 @@ profile
 *.moved-aside
 # Desktop Servies
 .DS_Store
-/Pods/
 script/env.sh
 
 /Masonry.xcworkspace/xcshareddata/Masonry.xccheckout

Pods/BuildHeaders/Expecta/EXPBackwardCompatibility.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPBackwardCompatibility.h

Pods/BuildHeaders/Expecta/EXPBlockDefinedMatcher.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPBlockDefinedMatcher.h

Pods/BuildHeaders/Expecta/EXPDefines.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPDefines.h

Pods/BuildHeaders/Expecta/EXPDoubleTuple.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPDoubleTuple.h

Pods/BuildHeaders/Expecta/EXPExpect.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPExpect.h

Pods/BuildHeaders/Expecta/EXPFloatTuple.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPFloatTuple.h

Pods/BuildHeaders/Expecta/EXPMatcher.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPMatcher.h

Pods/BuildHeaders/Expecta/EXPMatcherHelpers.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatcherHelpers.h

Pods/BuildHeaders/Expecta/EXPMatchers+beCloseTo.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beCloseTo.h

Pods/BuildHeaders/Expecta/EXPMatchers+beFalsy.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beFalsy.h

Pods/BuildHeaders/Expecta/EXPMatchers+beGreaterThan.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beGreaterThan.h

Pods/BuildHeaders/Expecta/EXPMatchers+beGreaterThanOrEqualTo.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beGreaterThanOrEqualTo.h

Pods/BuildHeaders/Expecta/EXPMatchers+beIdenticalTo.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beIdenticalTo.h

Pods/BuildHeaders/Expecta/EXPMatchers+beInTheRangeOf.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beInTheRangeOf.h

Pods/BuildHeaders/Expecta/EXPMatchers+beInstanceOf.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beInstanceOf.h

Pods/BuildHeaders/Expecta/EXPMatchers+beKindOf.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beKindOf.h

Pods/BuildHeaders/Expecta/EXPMatchers+beLessThan.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beLessThan.h

Pods/BuildHeaders/Expecta/EXPMatchers+beLessThanOrEqualTo.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beLessThanOrEqualTo.h

Pods/BuildHeaders/Expecta/EXPMatchers+beNil.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beNil.h

Pods/BuildHeaders/Expecta/EXPMatchers+beSubclassOf.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beSubclassOf.h

Pods/BuildHeaders/Expecta/EXPMatchers+beTruthy.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+beTruthy.h

Pods/BuildHeaders/Expecta/EXPMatchers+conformTo.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+conformTo.h

Pods/BuildHeaders/Expecta/EXPMatchers+contain.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+contain.h

Pods/BuildHeaders/Expecta/EXPMatchers+equal.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+equal.h

Pods/BuildHeaders/Expecta/EXPMatchers+haveCountOf.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+haveCountOf.h

Pods/BuildHeaders/Expecta/EXPMatchers+raise.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+raise.h

Pods/BuildHeaders/Expecta/EXPMatchers+raiseWithReason.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers+raiseWithReason.h

Pods/BuildHeaders/Expecta/EXPMatchers.h

@@ -0,0 +1 @@
+../../Expecta/src/matchers/EXPMatchers.h

Pods/BuildHeaders/Expecta/EXPUnsupportedObject.h

@@ -0,0 +1 @@
+../../Expecta/src/EXPUnsupportedObject.h

Pods/BuildHeaders/Expecta/Expecta.h

@@ -0,0 +1 @@
+../../Expecta/src/Expecta.h

Pods/BuildHeaders/Expecta/ExpectaSupport.h

@@ -0,0 +1 @@
+../../Expecta/src/ExpectaSupport.h

Pods/BuildHeaders/Expecta/NSObject+Expecta.h

@@ -0,0 +1 @@
+../../Expecta/src/NSObject+Expecta.h

Pods/BuildHeaders/Expecta/NSValue+Expecta.h

@@ -0,0 +1 @@
+../../Expecta/src/NSValue+Expecta.h

Pods/BuildHeaders/Masonry/MASCompositeConstraint.h

@@ -0,0 +1 @@
+../../../Masonry/MASCompositeConstraint.h

Pods/BuildHeaders/Masonry/MASConstraint+Private.h

@@ -0,0 +1 @@
+../../../Masonry/MASConstraint+Private.h

Pods/BuildHeaders/Masonry/MASConstraint.h

@@ -0,0 +1 @@
+../../../Masonry/MASConstraint.h

Pods/BuildHeaders/Masonry/MASConstraintMaker.h

@@ -0,0 +1 @@
+../../../Masonry/MASConstraintMaker.h

Pods/BuildHeaders/Masonry/MASLayoutConstraint.h

@@ -0,0 +1 @@
+../../../Masonry/MASLayoutConstraint.h

Pods/BuildHeaders/Masonry/MASUtilities.h

@@ -0,0 +1 @@
+../../../Masonry/MASUtilities.h

Pods/BuildHeaders/Masonry/MASViewAttribute.h

@@ -0,0 +1 @@
+../../../Masonry/MASViewAttribute.h

Pods/BuildHeaders/Masonry/MASViewConstraint.h

@@ -0,0 +1 @@
+../../../Masonry/MASViewConstraint.h

Pods/BuildHeaders/Masonry/Masonry.h

@@ -0,0 +1 @@
+../../../Masonry/Masonry.h

Pods/BuildHeaders/Masonry/NSArray+MASAdditions.h

@@ -0,0 +1 @@
+../../../Masonry/NSArray+MASAdditions.h

Pods/BuildHeaders/Masonry/NSArray+MASShorthandAdditions.h

@@ -0,0 +1 @@
+../../../Masonry/NSArray+MASShorthandAdditions.h

Pods/BuildHeaders/Masonry/NSLayoutConstraint+MASDebugAdditions.h

@@ -0,0 +1 @@
+../../../Masonry/NSLayoutConstraint+MASDebugAdditions.h

Pods/BuildHeaders/Masonry/View+MASAdditions.h

@@ -0,0 +1 @@
+../../../Masonry/View+MASAdditions.h

Pods/BuildHeaders/Masonry/View+MASShorthandAdditions.h

@@ -0,0 +1 @@
+../../../Masonry/View+MASShorthandAdditions.h

Pods/Expecta/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011-2012 Specta Team - https://github.com/specta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Pods/Expecta/README.md

@@ -0,0 +1,257 @@
+# Expecta
+
+A Matcher Framework for Objective-C/Cocoa
+
+## NOTICE
+
+Expecta 0.2.x has a new syntax that is slightly different from Expecta 0.1.x. For example `expect(x).toEqual(y)` should now be written as `expect(x).to.equal(y)`. You can do `#define EXP_OLD_SYNTAX` before importing `Expecta.h` to enable backward-compatiblity mode, but keep in mind that the old syntax is deprecated.
+
+## INTRODUCTION
+
+The main advantage of using Expecta over other matcher frameworks is that you do not have to specify the data types. Also, the syntax of Expecta matchers is much more readable and does not suffer from parenthesitis.
+
+**OCHamcrest**
+
+```objective-c
+assertThat(@"foo", is(equalTo(@"foo")));
+assertThatUnsignedInteger(foo, isNot(equalToUnsignedInteger(1)));
+assertThatBool([bar isBar], is(equalToBool(YES)));
+assertThatDouble(baz, is(equalToDouble(3.14159)));
+```
+
+vs.
+
+**Expecta**
+
+```objective-c
+expect(@"foo").to.equal(@"foo"); // `to` is a syntatic sugar and can be safely omitted.
+expect(foo).notTo.equal(1);
+expect([bar isBar]).to.equal(YES);
+expect(baz).to.equal(3.14159);
+```
+
+## SETUP
+
+Use [CocoaPods](https://github.com/CocoaPods/CocoaPods)
+
+```ruby
+target :MyApp do
+  # your app dependencies
+end
+
+target :MyAppTests do
+  pod 'Expecta',     '~> 0.2.3'   # expecta matchers
+  # pod 'Specta',      '~> 0.1.11'  # specta bdd framework
+end
+```
+
+or
+
+1. Clone from Github.
+2. Run `rake` in project root to build.
+3. Copy and add all header files in `products` folder to the Spec/Test target in your Xcode project.
+4. For **OS X projects**, copy and add `libExpecta-macosx.a` in `products` folder to the Spec/Test target in your Xcode project.
+   For **iOS projects**, copy and add `libExpecta-ios-universal.a` in `products` folder to the Spec/Test target in your Xcode project.
+5. Add `-ObjC` to the "Other Linker Flags" build setting for the Spec/Test target in your Xcode project.
+6. Add the following to your test code.
+
+```objective-c
+// #define EXP_OLD_SYNTAX // enable backward-compatibility
+#define EXP_SHORTHAND
+#import "Expecta.h"
+```
+
+If `EXP_SHORTHAND` is not defined, expectations must be written with `EXP_expect` instead of `expect`.
+
+Expecta is framework-agnostic. It works well with OCUnit (SenTestingKit) and OCUnit-compatible test frameworks such as [Specta](http://github.com/petejkim/specta/), [GHUnit](http://github.com/gabriel/gh-unit/) and [GTMUnit](http://code.google.com/p/google-toolbox-for-mac/). Expecta also supports [Cedar](http://pivotal.github.com/cedar/).
+
+## BUILT-IN MATCHERS
+
+>`expect(x).to.equal(y);` compares objects or primitives x and y and passes if they are identical (==) or equivalent (isEqual:).
+>
+>`expect(x).to.beIdenticalTo(y);` compares objects x and y and passes if they are identical and have the same memory address.
+>
+>`expect(x).to.beNil();` passes if x is nil.
+>
+>`expect(x).to.beTruthy();` passes if x evaluates to true (non-zero).
+>
+>`expect(x).to.beFalsy();` passes if x evaluates to false (zero).
+>
+>`expect(x).to.contain(y);` passes if an instance of NSArray, NSDictionary or NSString x contains y.
+>
+>`expect(x).to.haveCountOf(y);` passes if an instance of NSArray, NSSet, NSDictionary or NSString x has a count or length of y.
+>
+>`expect(x).to.beEmpty();` passes if an instance of NSArray, NSSet, NSDictionary or NSString x has a count or length of 0.
+>
+>`expect(x).to.beInstanceOf([Foo class]);` passes if x is an instance of a class Foo.
+>
+>`expect(x).to.beKindOf([Foo class]);` passes if x is an instance of a class Foo or if x is an instance of any class that inherits from the class Foo.
+>
+>`expect([Foo class]).to.beSubclassOf([Bar class]);` passes if the class Foo is a subclass of the class Bar or if it is identical to the class Bar. Use beKindOf() for class clusters.
+>
+>`expect(x).to.beLessThan(y);` passes if `x` is less than `y`.
+>
+>`expect(x).to.beLessThanOrEqualTo(y);` passes if `x` is less than or equal to `y`.
+>
+>`expect(x).to.beGreaterThan(y);` passes if `x` is greater than `y`.
+>
+>`expect(x).to.beGreaterThanOrEqualTo(y);` passes if `x` is greater than or equal to `y`.
+>
+>`expect(x).to.beInTheRangeOf(y,z);` passes if `x` is in the range of `y` and `z`.
+>
+>`expect(x).to.beCloseTo(y);` passes if `x` is close to `y`.
+>
+>`expect(x).to.beCloseToWithin(y, z);` passes if `x` is close to `y` within `z`.
+>
+>`expect(^{ /* code */ }).to.raise(@"ExceptionName");` passes if a given block of code raises an exception named `ExceptionName`.
+>
+>`expect(^{ /* code */ }).to.raiseAny();` passes if a given block of code raises any exception.
+
+**Please contribute more matchers.**
+
+## INVERTING MATCHERS
+
+Every matcher's criteria can be inverted by prepending `.notTo` or `.toNot`:
+
+>`expect(x).notTo.equal(y);` compares objects or primitives x and y and passes if they are *not* equivalent.
+
+## ASYNCHRONOUS TESTING
+
+Every matcher can be made to perform asynchronous testing by prepending `.will` or `.willNot`:
+
+>`expect(x).will.beNil();` passes if x becomes nil before the timeout.
+>
+>`expect(x).willNot.beNil();` passes if x becomes non-nil before the timeout.
+
+Default timeout is 1.0 second. This setting can be changed by calling `[Expecta setAsynchronousTestTimeout:x]`, where x is the desired timeout.
+
+## WRITING NEW MATCHERS
+
+Writing a new matcher is easy with special macros provided by Expecta. Take a look at how `.beKindOf()` matcher is defined:
+
+`EXPMatchers+beKindOf.h`
+
+```objective-c
+#import "Expecta.h"
+
+EXPMatcherInterface(beKindOf, (Class expected));
+// 1st argument is the name of the matcher function
+// 2nd argument is the list of arguments that may be passed in the function call.
+// Multiple arguments are fine. (e.g. (int foo, float bar))
+
+#define beAKindOf beKindOf
+```
+
+`EXPMatchers+beKindOf.m`
+
+```objective-c
+#import "EXPMatchers+beKindOf.h"
+
+EXPMatcherImplementationBegin(beKindOf, (Class expected)) {
+  BOOL actualIsNil = (actual == nil);
+  BOOL expectedIsNil = (expected == nil);
+
+  prerequisite(^BOOL{
+    return !(actualIsNil || expectedIsNil);
+    // Return `NO` if matcher should fail whether or not the result is inverted using `.Not`.
+  });
+
+  match(^BOOL{
+    return [actual isKindOfClass:expected];
+    // Return `YES` if the matcher should pass, `NO` if it should not.
+    // The actual value/object is passed as `actual`.
+    // Please note that primitive values will be wrapped in NSNumber/NSValue.
+  });
+
+  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]];
+    // Return the message to be displayed when the match function returns `YES`.
+  });
+
+  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]];
+    // Return the message to be displayed when the match function returns `NO`.
+  });
+}
+EXPMatcherImplementationEnd
+```
+
+## DYNAMIC PREDICATE MATCHERS
+
+It is possible to add predicate matchers by simply defining the matcher interface, with the matcher implementation being handled at runtime by delegating to the predicate method on your object.
+
+For instance, if you have the following class:
+
+```objc
+@interface LightSwitch : NSObject
+@property (nonatomic, assign, getter=isTurnedOn) BOOL turnedOn;
+@end
+
+@implementation LightSwitch
+@synthesize turnedOn;
+@end
+```
+
+The normal way to write an assertion that the switch is turned on would be:
+
+```objc
+expect([lightSwitch isTurnedOn]).to.beTruthy();
+```
+
+However, if we define a custom predicate matcher:
+
+```objc
+EXPMatcherInterface(isTurnedOn, (void));
+```
+
+(Note: we haven't defined the matcher implementation, just it's interface)
+
+You can now write your assertion as follows:
+
+```objc
+expect(lightSwitch).isTurnedOn();
+```
+
+## CONTRIBUTION
+
+You can find the public Tracker project [here](https://www.pivotaltracker.com/projects/323267).
+
+### CONTRIBUTION GUIDELINES
+
+* Please use only spaces and indent 2 spaces at a time.
+* Please prefix instance variable names with a single underscore (`_`).
+* Please prefix custom classes and functions defined in the global scope with `EXP`.
+
+## CREDITS
+
+Expecta is brought to you by [Peter Jihoon Kim](http://github.com/petejkim) and the [Specta team](https://github.com/specta?tab=members).
+
+### CONTRIBUTORS
+
+* [Alan Rogers](https://github.com/alanjrogers)
+* [Andrew Kitchen](https://github.com/akitchen)
+* [Blake Watters](https://github.com/blakewatters)
+* [Christopher Pickslay](https://github.com/twobitlabs)
+* [Chris Devereux](https://github.com/chrisdevereux)
+* [David Hart](https://github.com/TrahDivad)
+* [Jacob Gorban](https://github.com/apparentsoft)
+* [Jon Cooper](https://github.com/joncooper)
+* [Justin Spahr-Summers](https://github.com/jspahrsummers)
+* [Kurtis Seebaldt](https://github.com/kseebaldt)
+* [Luke Redpath](https://github.com/lukeredpath)
+* [Nicholas Hutchinson](https://github.com/nickhutchinson)
+* [Rob Rix](https://github.com/robrix)
+* [Samuel Giddins](https://github.com/segiddins)
+* [Zack Waugh](https://github.com/zachwaugh)
+
+## LICENSE
+
+Expecta is licensed under the [MIT License](http://github.com/petejkim/expecta/raw/master/LICENSE).

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

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

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

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

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

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

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

Pods/Expecta/src/EXPExpect.h

@@ -0,0 +1,42 @@
+#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;
+}
+
+@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, readonly) EXPExpect *to;
+@property(nonatomic, readonly) EXPExpect *toNot;
+@property(nonatomic, readonly) EXPExpect *notTo;
+@property(nonatomic, readonly) EXPExpect *will;
+@property(nonatomic, readonly) EXPExpect *willNot;
+
+- (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

Pods/Expecta/src/EXPExpect.m

@@ -0,0 +1,200 @@
+#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;
+
+@synthesize
+  actualBlock=_actualBlock,
+  testCase=_testCase,
+  negative=_negative,
+  asynchronous=_asynchronous,
+  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.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;
+}
+
+#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 = [Expecta asynchronousTestTimeout];
+        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

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

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

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

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

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

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(actual) EXP_expect((actual))
+#endif
+
+#ifdef EXP_OLD_SYNTAX
+#  import "EXPBackwardCompatibility.h"
+#endif
+
+@interface Expecta : NSObject
+
++ (NSTimeInterval)asynchronousTestTimeout;
++ (void)setAsynchronousTestTimeout:(NSTimeInterval)timeout;
+
+@end

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

Pods/Expecta/src/ExpectaSupport.h

@@ -0,0 +1,56 @@
+#import "EXPExpect.h"
+#import "EXPBlockDefinedMatcher.h"
+
+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

Pods/Expecta/src/ExpectaSupport.m

@@ -0,0 +1,188 @@
+#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]]) {
+    if([obj isKindOfClass:[NSValue class]] && ![obj isKindOfClass:[NSNumber class]]) {
+      void *pointerValue = [obj pointerValue];
+      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(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 {
+    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];
+}
+

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

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

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

Pods/Expecta/src/matchers/EXPMatcherHelpers.h

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

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;
+}

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)))

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

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

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

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

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)))

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

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)))

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

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

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

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

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)))

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

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

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

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

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

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

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)))

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

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)))

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

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

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

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

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

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

Pods/Expecta/src/matchers/EXPMatchers+beSubclassOf.m

@@ -0,0 +1,27 @@
+#import "EXPMatchers+beSubclassOf.h"
+#import "NSValue+Expecta.h"
+#import <objc/runtime.h>
+
+EXPMatcherImplementationBegin(beSubclassOf, (Class expected)) {
+  __block BOOL actualIsClass = YES;
+
+  prerequisite(^BOOL {
+    actualIsClass = class_isMetaClass(object_getClass(actual));
+    return actualIsClass;
+  });
+
+  match(^BOOL{
+    return [actual isSubclassOfClass:expected];
+  });
+
+  failureMessageForTo(^NSString *{
+    if(!actualIsClass) return @"the actual value is not a Class";
+    return [NSString stringWithFormat:@"expected: a subclass of %@, got: a class %@, which is not a subclass of %@", [expected class], actual, [expected class]];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    if(!actualIsClass) return @"the actual value is not a Class";
+    return [NSString stringWithFormat:@"expected: not a subclass of %@, got: a class %@, which is a subclass of %@", [expected class], actual, [expected class]];
+  });
+}
+EXPMatcherImplementationEnd

Pods/Expecta/src/matchers/EXPMatchers+beTruthy.h

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

Pods/Expecta/src/matchers/EXPMatchers+beTruthy.m

@@ -0,0 +1,24 @@
+#import "EXPMatchers+beTruthy.h"
+#import "EXPMatcherHelpers.h"
+
+EXPMatcherImplementationBegin(beTruthy, (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 truthy value, got: %@, which is falsy", EXPDescribeObject(actual)];
+  });
+
+  failureMessageForNotTo(^NSString *{
+    return [NSString stringWithFormat:@"expected: a non-truthy value, got: %@, which is truthy", EXPDescribeObject(actual)];
+  });
+}
+EXPMatcherImplementationEnd

Pods/Expecta/src/matchers/EXPMatchers+conformTo.h

@@ -0,0 +1,3 @@
+#import "Expecta.h"
+
+EXPMatcherInterface(conformTo, (Protocol *expected));