second_curtain 0.2.2 → 0.2.3

data/Demo/Pods/Specta/src/SPTSharedExampleGroups.m

@@ -0,0 +1,62 @@
+#import "SPTSharedExampleGroups.h"
+#import "SPTExampleGroup.h"
+#import "SPTXCTestCase.h"
+#import "SpectaUtility.h"
+#import <objc/runtime.h>
+
+NSMutableDictionary *globalSharedExampleGroups = nil;
+BOOL initialized = NO;
+
+@implementation SPTSharedExampleGroups
+
++ (void)initialize {
+  Class SPTSharedExampleGroupsClass = [SPTSharedExampleGroups class];
+  if ([self class] == SPTSharedExampleGroupsClass) {
+    if (!initialized) {
+      initialized = YES;
+      globalSharedExampleGroups = [[NSMutableDictionary alloc] init];
+
+      Class *classes = NULL;
+      int numClasses = objc_getClassList(NULL, 0);
+
+      if (numClasses > 0) {
+        classes = (Class *)malloc(sizeof(Class) * numClasses);
+        numClasses = objc_getClassList(classes, numClasses);
+
+        Class klass, superClass;
+        for(uint i = 0; i < numClasses; i++) {
+          klass = classes[i];
+          superClass = class_getSuperclass(klass);
+          if (superClass == SPTSharedExampleGroupsClass) {
+            [klass defineSharedExampleGroups];
+          }
+        }
+
+        free(classes);
+      }
+    }
+  }
+}
+
++ (void)addSharedExampleGroupWithName:(NSString *)name block:(SPTDictionaryBlock)block exampleGroup:(SPTExampleGroup *)exampleGroup {
+  (exampleGroup == nil ? globalSharedExampleGroups : exampleGroup.sharedExamples)[name] = [block copy];
+}
+
++ (SPTDictionaryBlock)sharedExampleGroupWithName:(NSString *)name exampleGroup:(SPTExampleGroup *)exampleGroup {
+  SPTDictionaryBlock sharedExampleGroup = nil;
+  while (exampleGroup != nil) {
+    if ((sharedExampleGroup = exampleGroup.sharedExamples[name])) {
+      return sharedExampleGroup;
+    }
+    exampleGroup = exampleGroup.parent;
+  }
+  return globalSharedExampleGroups[name];
+}
+
++ (void)defineSharedExampleGroups {}
+
++ (void)recordFailureWithDescription:(NSString *)description inFile:(NSString *)filename atLine:(NSUInteger)lineNumber expected:(BOOL)expected {
+  [SPTCurrentTestCase recordFailureWithDescription:description inFile:filename atLine:lineNumber expected:expected];
+}
+
+@end

data/Demo/Pods/Specta/src/SPTSpec.h

@@ -0,0 +1,21 @@
+#import <Foundation/Foundation.h>
+
+@class
+  SPTExample
+, SPTExampleGroup
+;
+
+@interface SPTSpec : NSObject
+
+@property (nonatomic, strong) SPTExampleGroup *rootGroup;
+@property (nonatomic, strong) NSMutableArray *groupStack;
+@property (nonatomic, strong) NSArray *compiledExamples;
+@property (nonatomic, strong) NSString *fileName;
+@property (nonatomic) NSUInteger lineNumber;
+@property (nonatomic, getter = isDisabled) BOOL disabled;
+@property (nonatomic) BOOL hasFocusedExamples;
+
+- (SPTExampleGroup *)currentGroup;
+- (void)compile;
+
+@end

data/Demo/Pods/Specta/src/SPTSpec.m

@@ -0,0 +1,31 @@
+#import "SPTSpec.h"
+#import "SPTExampleGroup.h"
+#import "SPTExample.h"
+
+@implementation SPTSpec
+
+- (id)init {
+  self = [super init];
+  if (self) {
+    self.rootGroup = [[SPTExampleGroup alloc] init];
+    self.rootGroup.root = self.rootGroup;
+    self.groupStack = [NSMutableArray arrayWithObject:self.rootGroup];
+  }
+  return self;
+}
+
+- (SPTExampleGroup *)currentGroup {
+  return [self.groupStack lastObject];
+}
+
+- (void)compile {
+  self.compiledExamples = [self.rootGroup compileExamplesWithNameStack:@[]];
+  for (SPTExample *example in self.compiledExamples) {
+    if (example.focused) {
+      self.hasFocusedExamples = YES;
+      break;
+    }
+  }
+}
+
+@end

data/Demo/Pods/Specta/src/SPTXCTestCase.h

@@ -0,0 +1,27 @@
+#import <XCTest/XCTest.h>
+#import "XCTestCase+Specta.h"
+
+@class
+  SPTSpec
+, SPTExample
+;
+
+@interface SPTXCTestCase : XCTestCase
+
+@property (nonatomic, strong) NSInvocation *spt_invocation;
+@property (nonatomic, strong) XCTestCaseRun *spt_run;
+@property (nonatomic, assign) BOOL spt_skipped;
+@property (nonatomic, assign, readonly, getter = spt_isPending) BOOL spt_pending;
+
++ (BOOL)spt_isDisabled;
++ (void)spt_setDisabled:(BOOL)disabled;
++ (BOOL)spt_focusedExamplesExist;
+
++ (SPTSpec *)spt_spec;
+- (void)spt_setCurrentSpecWithFileName:(const char *)fileName lineNumber:(NSUInteger)lineNumber;
+- (void)spt_defineSpec;
+- (void)spt_unsetCurrentSpec;
+- (void)spt_runExampleAtIndex:(NSUInteger)index;
+- (SPTExample *)spt_getCurrentExample;
+
+@end

data/Demo/Pods/Specta/src/SPTXCTestCase.m

@@ -0,0 +1,151 @@
+#import "SPTXCTestCase.h"
+#import "SPTSpec.h"
+#import "SPTExample.h"
+#import "SPTSharedExampleGroups.h"
+#import "SpectaUtility.h"
+#import <objc/runtime.h>
+
+@implementation SPTXCTestCase
+
++ (void)initialize {
+  [SPTSharedExampleGroups initialize];
+  SPTSpec *spec = [[SPTSpec alloc] init];
+  SPTXCTestCase *testCase = [[[self class] alloc] init];
+  objc_setAssociatedObject(self, "spt_spec", spec, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  [testCase spt_defineSpec];
+  [spec compile];
+  [super initialize];
+}
+
++ (SPTSpec *)spt_spec {
+  return objc_getAssociatedObject(self, "spt_spec");
+}
+
++ (BOOL)spt_isDisabled {
+  return [self spt_spec].disabled;
+}
+
++ (void)spt_setDisabled:(BOOL)disabled {
+  [self spt_spec].disabled = disabled;
+}
+
+- (BOOL)spt_isPending {
+  SPTExample *example = [self spt_getCurrentExample];
+  return example == nil || example.pending;
+}
+
++ (NSArray *)spt_allSpecClasses {
+  static NSArray *allSpecClasses = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+
+    NSMutableArray *specClasses = [[NSMutableArray alloc] init];
+
+    int numberOfClasses = objc_getClassList(NULL, 0);
+    if (numberOfClasses > 0) {
+      Class *classes = (Class *)malloc(sizeof(Class) * numberOfClasses);
+      numberOfClasses = objc_getClassList(classes, numberOfClasses);
+
+      for (int classIndex = 0; classIndex < numberOfClasses; classIndex++) {
+        Class aClass = classes[classIndex];
+        if (SPTIsSpecClass(aClass)) {
+          [specClasses addObject:aClass];
+        }
+      }
+
+      free(classes);
+    }
+
+    allSpecClasses = [specClasses copy];
+  });
+
+  return allSpecClasses;
+}
+
++ (BOOL)spt_focusedExamplesExist {
+  for (Class specClass in [self spt_allSpecClasses]) {
+    SPTSpec *spec = [specClass spt_spec];
+    if (spec.disabled == NO && [spec hasFocusedExamples]) {
+      return YES;
+    }
+  }
+
+  return NO;
+}
+
+- (void)spt_setCurrentSpecWithFileName:(const char *)fileName lineNumber:(NSUInteger)lineNumber {
+  SPTSpec *spec = [[self class] spt_spec];
+  spec.fileName = @(fileName);
+  spec.lineNumber = lineNumber;
+  [[NSThread currentThread] threadDictionary][SPTCurrentSpecKey] = spec;
+}
+
+- (void)spt_defineSpec {}
+
+- (void)spt_unsetCurrentSpec {
+  [[[NSThread currentThread] threadDictionary] removeObjectForKey:SPTCurrentSpecKey];
+}
+
+- (void)spt_runExampleAtIndex:(NSUInteger)index {
+  [[NSThread currentThread] threadDictionary][SPTCurrentTestCaseKey] = self;
+  SPTExample *compiledExample = ([[self class] spt_spec].compiledExamples)[index];
+  if (!compiledExample.pending) {
+    if ([[self class] spt_isDisabled] == NO &&
+        (compiledExample.focused || [[self class] spt_focusedExamplesExist] == NO)) {
+      ((SPTVoidBlock)compiledExample.block)();
+    } else {
+      self.spt_skipped = YES;
+    }
+  }
+
+  [[[NSThread currentThread] threadDictionary] removeObjectForKey:SPTCurrentTestCaseKey];
+}
+
+- (SPTExample *)spt_getCurrentExample {
+  if (!self.spt_invocation) {
+    return nil;
+  }
+  NSUInteger i;
+  [self.spt_invocation getArgument:&i atIndex:2];
+  return ([[self class] spt_spec].compiledExamples)[i];
+}
+
+#pragma mark - XCTestCase overrides
+
++ (NSArray *)testInvocations {
+  NSMutableArray *invocations = [NSMutableArray array];
+  for(NSUInteger i = 0; i < [[self spt_spec].compiledExamples count]; i ++) {
+    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[self instanceMethodSignatureForSelector:@selector(spt_runExampleAtIndex:)]];
+    NSUInteger j = i;
+    [invocation setSelector:@selector(spt_runExampleAtIndex:)];
+    [invocation setArgument:&j atIndex:2];
+    [invocations addObject:invocation];
+  }
+  return invocations;
+}
+
+- (void)setInvocation:(NSInvocation *)invocation {
+  self.spt_invocation = invocation;
+  [super setInvocation:invocation];
+}
+
+- (NSString *)name {
+  NSString *specName = NSStringFromClass([self class]);
+  SPTExample *compiledExample = [self spt_getCurrentExample];
+  NSCharacterSet *charSet = [NSCharacterSet characterSetWithCharactersInString:@"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"];
+  NSString *exampleName = [[compiledExample.name componentsSeparatedByCharactersInSet:[charSet invertedSet]] componentsJoinedByString:@"_"];
+  return [NSString stringWithFormat:@"-[%@ %@]", specName, exampleName];
+}
+
+- (void)recordFailureWithDescription:(NSString *)description inFile:(NSString *)filename atLine:(NSUInteger)lineNumber expected:(BOOL)expected {
+  SPTXCTestCase *currentTestCase = SPTCurrentTestCase;
+  [currentTestCase.spt_run recordFailureInTest:currentTestCase withDescription:description inFile:filename atLine:lineNumber expected:expected];
+}
+
+- (void)performTest:(XCTestRun *)run {
+  self.spt_run = (XCTestCaseRun *)run;
+  [super performTest:run];
+  self.spt_run = nil;
+}
+
+@end

data/Demo/Pods/Specta/src/SPTXCTestReporter.h

@@ -0,0 +1,9 @@
+#import "SPTReporter.h"
+
+/**
+ *  Reporter that produces output identical to XCode's default output. Useful when integrating with 3rd-party tools that
+ *  may not like SPTNestedReporter's indented output.
+ */
+@interface SPTXCTestReporter : SPTReporter
+
+@end

data/Demo/Pods/Specta/src/SPTXCTestReporter.m

@@ -0,0 +1,11 @@
+#import "SPTXCTestReporter.h"
+
+@implementation SPTXCTestReporter
+
+/*
+ * Intentionally left blank.
+ * This class is included for future-compatibility just in case we need to
+ * weak reporter output for users who want test output idential to XCTestLog.
+ */
+
+@end

data/Demo/Pods/Specta/src/Specta.h

@@ -0,0 +1,70 @@
+#import <Foundation/Foundation.h>
+#import <XCTest/XCTest.h>
+#import "SpectaSupport.h"
+#import "SPTXCTestCase.h"
+#import "SPTSpec.h"
+#import "SPTExampleGroup.h"
+#import "SPTSharedExampleGroups.h"
+
+@interface Specta : NSObject
+@end
+
+#define SpecBegin(name)    _SPTSpecBegin(name, __FILE__, __LINE__)
+#define SpecEnd            _SPTSpecEnd
+
+#define SharedExamplesBegin(name)      _SPTSharedExampleGroupsBegin(name)
+#define SharedExamplesEnd              _SPTSharedExampleGroupsEnd
+#define SharedExampleGroupsBegin(name) _SPTSharedExampleGroupsBegin(name)
+#define SharedExampleGroupsEnd         _SPTSharedExampleGroupsEnd
+
+#ifdef SPT_CEDAR_SYNTAX
+#  define SPEC_BEGIN(name) SpecBegin(name)
+#  define SPEC_END         SpecEnd
+#  define SHARED_EXAMPLE_GROUPS_BEGIN(name) SharedExamplesBegin(name)
+#  define SHARED_EXAMPLE_GROUPS_END         SharedExamplesEnd
+#  ifndef PENDING
+#    define PENDING nil
+#  endif
+#endif
+
+void SPTdescribe(NSString *name, BOOL focused, void (^block)());
+void    describe(NSString *name, void (^block)());
+void   fdescribe(NSString *name, void (^block)());
+void     context(NSString *name, void (^block)());
+void    fcontext(NSString *name, void (^block)());
+
+void SPTexample(NSString *name, BOOL focused, id block);
+void    example(NSString *name, id block);
+void   fexample(NSString *name, id block);
+void         it(NSString *name, id block);
+void        fit(NSString *name, id block);
+void    specify(NSString *name, id block);
+void   fspecify(NSString *name, id block);
+
+
+void SPTpending(NSString *name, ...);
+#define xdescribe(...) SPTpending(__VA_ARGS__, nil)
+#define  xcontext(...) SPTpending(__VA_ARGS__, nil)
+#define  xexample(...) SPTpending(__VA_ARGS__, nil)
+#define       xit(...) SPTpending(__VA_ARGS__, nil)
+#define  xspecify(...) SPTpending(__VA_ARGS__, nil)
+#define   pending(...) SPTpending(__VA_ARGS__, nil)
+
+void  beforeAll(id block);
+void   afterAll(id block);
+void beforeEach(id block);
+void  afterEach(id block);
+void     before(id block);
+void      after(id block);
+
+void sharedExamplesFor(NSString *name, void (^block)(NSDictionary *data));
+void    sharedExamples(NSString *name, void (^block)(NSDictionary *data));
+
+void SPTitShouldBehaveLike(const char *fileName, NSUInteger lineNumber, NSString *name, id dictionaryOrBlock);
+void    itShouldBehaveLike(NSString *name, id dictionaryOrBlockOrNil); // aid code completion
+void         itBehavesLike(NSString *name, id dictionaryOrBlockOrNil);
+#define itShouldBehaveLike(...) SPTitShouldBehaveLike(__FILE__, __LINE__, __VA_ARGS__)
+#define      itBehavesLike(...) SPTitShouldBehaveLike(__FILE__, __LINE__, __VA_ARGS__)
+
+void setAsyncSpecTimeout(NSTimeInterval timeout);
+#define AsyncBlock (void (^done)(void))

data/Demo/Pods/Specta/src/Specta.m

@@ -0,0 +1,144 @@
+#import "Specta.h"
+#import "SpectaTypes.h"
+#import "SpectaUtility.h"
+
+@implementation Specta
+@end
+
+void SPTdescribe(NSString *name, BOOL focused, void (^block)()) {
+  if (block) {
+    [SPTGroupStack addObject:[SPTCurrentGroup addExampleGroupWithName:name focused:focused]];
+    block();
+    [SPTGroupStack removeLastObject];
+  } else {
+    SPTexample(name, focused, nil);
+  }
+}
+
+void describe(NSString *name, void (^block)()) {
+  SPTdescribe(name, NO, block);
+}
+
+void fdescribe(NSString *name, void (^block)()) {
+  SPTdescribe(name, YES, block);
+}
+
+void context(NSString *name, void (^block)()) {
+  SPTdescribe(name, NO, block);
+}
+void fcontext(NSString *name, void (^block)()) {
+  SPTdescribe(name, YES, block);
+}
+
+void SPTexample(NSString *name, BOOL focused, id block) {
+  SPTReturnUnlessBlockOrNil(block);
+  [SPTCurrentGroup addExampleWithName:name block:block focused:focused];
+}
+
+void example(NSString *name, id block) {
+  SPTexample(name, NO, block);
+}
+
+void fexample(NSString *name, id block) {
+  SPTexample(name, YES, block);
+}
+
+void it(NSString *name, id block) {
+  SPTexample(name, NO, block);
+}
+
+void fit(NSString *name, id block) {
+  SPTexample(name, YES, block);
+}
+
+void specify(NSString *name, id block) {
+  SPTexample(name, NO, block);
+}
+
+void fspecify(NSString *name, id block) {
+  SPTexample(name, YES, block);
+}
+
+void SPTpending(NSString *name, ...) {
+  SPTexample(name, NO, nil);
+}
+
+void beforeAll(id block) {
+  SPTReturnUnlessBlockOrNil(block);
+  [SPTCurrentGroup addBeforeAllBlock:block];
+}
+
+void afterAll(id block) {
+  SPTReturnUnlessBlockOrNil(block);
+  [SPTCurrentGroup addAfterAllBlock:block];
+}
+
+void beforeEach(id block) {
+  SPTReturnUnlessBlockOrNil(block);
+  [SPTCurrentGroup addBeforeEachBlock:block];
+}
+
+void afterEach(id block) {
+  SPTReturnUnlessBlockOrNil(block);
+  [SPTCurrentGroup addAfterEachBlock:block];
+}
+
+void before(id block) {
+  beforeEach(block);
+}
+
+void after(id block) {
+  afterEach(block);
+}
+
+void sharedExamplesFor(NSString *name, void (^block)(NSDictionary *data)) {
+  [SPTSharedExampleGroups addSharedExampleGroupWithName:name block:block exampleGroup:SPTCurrentGroup];
+}
+
+void sharedExamples(NSString *name, void (^block)(NSDictionary *data)) {
+  sharedExamplesFor(name, block);
+}
+
+void SPTitShouldBehaveLike(const char *fileName, NSUInteger lineNumber, NSString *name, id dictionaryOrBlock) {
+  SPTDictionaryBlock block = [SPTSharedExampleGroups sharedExampleGroupWithName:name exampleGroup:SPTCurrentGroup];
+  if (block) {
+    if (SPTIsBlock(dictionaryOrBlock)) {
+      id (^dataBlock)(void) = [dictionaryOrBlock copy];
+
+      describe(name, ^{
+        __block NSMutableDictionary *dataDict = [[NSMutableDictionary alloc] init];
+
+        beforeEach(^{
+          NSDictionary *blockData = dataBlock();
+          [dataDict removeAllObjects];
+          [dataDict addEntriesFromDictionary:blockData];
+        });
+
+        block(dataDict);
+
+        afterAll(^{
+          dataDict = nil;
+        });
+      });
+    } else {
+      NSDictionary *data = dictionaryOrBlock;
+
+      describe(name, ^{
+        block(data);
+      });
+    }
+  } else {
+    SPTXCTestCase *currentTestCase = SPTCurrentTestCase;
+    if (currentTestCase) {
+      [currentTestCase recordFailureWithDescription:@"itShouldBehaveLike should not be invoked inside an example block!" inFile:@(fileName) atLine:lineNumber expected:NO];
+    } else {
+      it(name, ^{
+        [currentTestCase recordFailureWithDescription:[NSString stringWithFormat:@"Shared example group \"%@\" does not exist.", name] inFile:@(fileName) atLine:lineNumber expected:NO];
+      });
+    }
+  }
+}
+
+void setAsyncSpecTimeout(NSTimeInterval timeout) {
+  [SPTExampleGroup setAsyncSpecTimeout:timeout];
+}

data/Demo/Pods/Specta/src/SpectaSupport.h

@@ -0,0 +1,46 @@
+#ifndef SPT_SUBCLASS
+#define SPT_SUBCLASS SPTXCTestCase
+#endif
+
+
+
+#define _SPTSpecBegin(name, file, line) \
+@interface name##Spec : SPT_SUBCLASS \
+@end \
+@implementation name##Spec \
+- (void)spt_defineSpec { \
+  const char *specFileName = file; \
+  @try { \
+    [self spt_setCurrentSpecWithFileName:(file) lineNumber:(line)];
+
+#define _SPTSpecEnd \
+    [self spt_unsetCurrentSpec]; \
+  } @catch(NSException *exception) { \
+    fprintf(stderr, "%s: An exception has occured outside of tests, aborting.\n\n%s (%s) \n", specFileName, [[exception name] UTF8String], [[exception reason] UTF8String]); \
+    if ([exception respondsToSelector:@selector(callStackSymbols)]) { \
+      NSArray *callStackSymbols = [exception callStackSymbols]; \
+      if (callStackSymbols) { \
+        NSString *callStack = [NSString stringWithFormat:@"\n  Call Stack:\n    %@\n", [callStackSymbols componentsJoinedByString:@"\n    "]]; \
+        fprintf(stderr, "%s", [callStack UTF8String]); \
+      } \
+    } \
+    exit(1); \
+  } \
+} \
+@end
+
+#define _SPTSharedExampleGroupsBegin(name) \
+@interface name##SharedExampleGroups : SPTSharedExampleGroups \
+@end \
+@implementation name##SharedExampleGroups \
++ (void)defineSharedExampleGroups {
+
+#define _SPTSharedExampleGroupsEnd \
+} \
+@end
+
+#undef _XCTRegisterFailure
+#define _XCTRegisterFailure(condition, format...) \
+({ \
+_XCTFailureHandler((id)self, YES, __FILE__, __LINE__, condition, @"" format); \
+})

data/Demo/Pods/Specta/src/SpectaTypes.h

@@ -0,0 +1,3 @@
+typedef void (^SPTVoidBlock)();
+typedef void (^SPTAsyncBlock)(void (^)());
+typedef void (^SPTDictionaryBlock)(NSDictionary *dictionary);

data/Demo/Pods/Specta/src/SpectaUtility.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+extern NSString * const SPTCurrentSpecKey;
+extern NSString * const SPTCurrentTestCaseKey;
+
+#define SPTCurrentSpec     [[NSThread currentThread] threadDictionary][SPTCurrentSpecKey]
+#define SPTCurrentTestCase [[NSThread currentThread] threadDictionary][SPTCurrentTestCaseKey]
+#define SPTCurrentGroup    [SPTCurrentSpec currentGroup]
+#define SPTGroupStack      [SPTCurrentSpec groupStack]
+
+#define SPTReturnUnlessBlockOrNil(block) if ((block) && !SPTIsBlock((block))) return;
+#define SPTIsBlock(obj) [(obj) isKindOfClass:NSClassFromString(@"NSBlock")]
+
+const char *SPTGetBlockSignature(id blockObject);
+BOOL SPTIsSpecClass(Class aClass);

data/Demo/Pods/Specta/src/SpectaUtility.m

@@ -0,0 +1,65 @@
+#import "SpectaUtility.h"
+#import "SPTXCTestCase.h"
+#import <objc/runtime.h>
+
+NSString * const SPTCurrentSpecKey = @"SPTCurrentSpec";
+NSString * const SPTCurrentTestCaseKey = @"SPTCurrentTestCase";
+
+// http://clang.llvm.org/docs/Block-ABI-Apple.html
+struct SPTBlockLiteral {
+  void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock
+  int flags;
+  int reserved;
+  void (*invoke)(void *, ...);
+  struct Block_descriptor_1 {
+    unsigned long int reserved; // NULL
+    unsigned long int size;     // sizeof(struct Block_literal_1)
+    // optional helper functions
+    void (*copy_helper)(void *dst, void *src);     // IFF (1<<25)
+    void (*dispose_helper)(void *src);             // IFF (1<<25)
+    // required ABI.2010.3.16
+    const char *signature;                         // IFF (1<<30)
+  } *descriptor;
+  // imported variables
+};
+
+enum {
+  SPT_BLOCK_HAS_COPY_DISPOSE =  (1 << 25),
+  SPT_BLOCK_HAS_CTOR =          (1 << 26), // helpers have C++ code
+  SPT_BLOCK_IS_GLOBAL =         (1 << 28),
+  SPT_BLOCK_HAS_STRET =         (1 << 29), // IFF BLOCK_HAS_SIGNATURE
+  SPT_BLOCK_HAS_SIGNATURE =     (1 << 30),
+};
+
+const char *SPTGetBlockSignature(id blockObject) {
+  struct SPTBlockLiteral *block = (__bridge struct SPTBlockLiteral *)blockObject;
+
+  int flags = block->flags;
+
+  if (flags & SPT_BLOCK_HAS_SIGNATURE) {
+    void *signaturePtr = block->descriptor;
+    signaturePtr += sizeof(unsigned long int); // skip reserved
+    signaturePtr += sizeof(unsigned long int); // skip size
+
+    if (flags & SPT_BLOCK_HAS_COPY_DISPOSE) {
+      signaturePtr += sizeof(void(*)(void *dst, void *src)); // skip copy_helper
+      signaturePtr += sizeof(void(*)(void *src)); // skip dispose_helper
+    }
+
+    return *(const char **)signaturePtr;
+  }
+
+  return NULL;
+}
+
+BOOL SPTIsSpecClass(Class aClass) {
+  Class superclass = class_getSuperclass(aClass);
+  while (superclass != Nil) {
+    if (superclass == [SPTXCTestCase class]) {
+      return YES;
+    } else {
+      superclass = class_getSuperclass(superclass);
+    }
+  }
+  return NO;
+}

data/Demo/Pods/Specta/src/XCTestCase+Specta.h

@@ -0,0 +1,4 @@
+#import <XCTest/XCTest.h>
+
+@interface XCTestCase (Specta)
+@end