second_curtain 0.2.2 → 0.2.3

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

@@ -0,0 +1,326 @@
+#import "SPTExampleGroup.h"
+#import "SPTExample.h"
+#import "SPTXCTestCase.h"
+#import "SPTSpec.h"
+#import "SpectaUtility.h"
+#import <libkern/OSAtomic.h>
+#import <objc/runtime.h>
+
+static NSArray *ClassesWithClassMethod(SEL classMethodSelector) {
+  NSMutableArray *classesWithClassMethod = [[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 (strcmp("UIAccessibilitySafeCategory__NSObject", class_getName(aClass))) {
+        Method globalMethod = class_getClassMethod(aClass, classMethodSelector);
+        if (globalMethod) {
+          [classesWithClassMethod addObject:aClass];
+        }
+      }
+    }
+
+    free(classes);
+  }
+
+  return classesWithClassMethod;
+}
+
+@interface NSObject (SpectaGlobalBeforeAfterEach)
+
++ (void)beforeEach;
++ (void)afterEach;
+
+@end
+
+static NSTimeInterval asyncSpecTimeout = 10.0;
+static const char *asyncBlockSignature = NULL;
+
+static void runExampleBlock(id block, NSString *name) {
+  if (!SPTIsBlock(block)) {
+    return;
+  }
+
+  const char *blockSignature = SPTGetBlockSignature(block);
+
+  BOOL isAsyncBlock = strcmp(blockSignature, asyncBlockSignature) == 0;
+
+  if (isAsyncBlock) {
+    __block uint32_t complete = 0;
+    ((SPTAsyncBlock)block)(^{
+      OSAtomicOr32Barrier(1, &complete);
+    });
+    NSTimeInterval timeout = asyncSpecTimeout;
+    NSDate *timeoutDate = [NSDate dateWithTimeIntervalSinceNow:timeout];
+    while (!complete && [timeoutDate timeIntervalSinceNow] > 0) {
+      [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+    }
+    if (!complete) {
+      NSString *message = [NSString stringWithFormat:@"\"%@\" failed to invoke done() callback before timeout (%f seconds)", name, timeout];
+      SPTXCTestCase *currentTestCase = SPTCurrentTestCase;
+      SPTSpec *spec = [[currentTestCase class] spt_spec];
+      [currentTestCase recordFailureWithDescription:message inFile:spec.fileName atLine:spec.lineNumber expected:YES];
+    }
+  } else {
+    ((SPTVoidBlock)block)();
+  }
+}
+
+@interface SPTExampleGroup ()
+
+- (void)incrementExampleCount;
+- (void)resetRanExampleCountIfNeeded;
+- (void)incrementRanExampleCount;
+- (void)runBeforeHooks:(NSString *)compiledName;
+- (void)runAfterHooks:(NSString *)compiledName;
+
+@end
+
+@implementation SPTExampleGroup
+
++ (void)initialize {
+  if (asyncBlockSignature == NULL) {
+    asyncBlockSignature = SPTGetBlockSignature(^(void (^done)(void)) {});
+  }
+}
+
+- (id)init {
+  self = [super init];
+  if (self) {
+    self.name = nil;
+    self.root = nil;
+    self.parent = nil;
+    self.children = [NSMutableArray array];
+    self.beforeAllArray = [NSMutableArray array];
+    self.afterAllArray = [NSMutableArray array];
+    self.beforeEachArray = [NSMutableArray array];
+    self.afterEachArray = [NSMutableArray array];
+    self.sharedExamples = [NSMutableDictionary dictionary];
+    self.exampleCount = 0;
+    self.ranExampleCount = 0;
+  }
+  return self;
+}
+
++ (void)setAsyncSpecTimeout:(NSTimeInterval)timeout {
+  asyncSpecTimeout = timeout;
+}
+
+- (id)initWithName:(NSString *)name parent:(SPTExampleGroup *)parent root:(SPTExampleGroup *)root {
+  self = [self init];
+  if (self) {
+    self.name = name;
+    self.parent = parent;
+    self.root = root;
+  }
+  return self;
+}
+
+- (SPTExampleGroup *)addExampleGroupWithName:(NSString *)name {
+  return [self addExampleGroupWithName:name
+                               focused:NO];
+}
+
+
+- (SPTExampleGroup *)addExampleGroupWithName:(NSString *)name  focused:(BOOL)focused {
+  SPTExampleGroup *group = [[SPTExampleGroup alloc] initWithName:name parent:self root:self.root];
+  group.focused = focused;
+  [self.children addObject:group];
+  return group;
+}
+
+- (SPTExample *)addExampleWithName:(NSString *)name block:(id)block {
+  return [self addExampleWithName:name
+                            block:block
+                          focused:NO];
+}
+
+- (SPTExample *)addExampleWithName:(NSString *)name block:(id)block focused:(BOOL)focused {
+  SPTExample *example;
+  @synchronized(self) {
+    example = [[SPTExample alloc] initWithName:name block:block];
+    example.focused = focused;
+    [self.children addObject:example];
+    [self incrementExampleCount];
+  }
+  return example;
+}
+
+- (void)incrementExampleCount {
+  SPTExampleGroup *group = self;
+  while (group != nil) {
+    group.exampleCount ++;
+    group = group.parent;
+  }
+}
+
+- (void)resetRanExampleCountIfNeeded {
+  SPTExampleGroup *group = self;
+  while (group != nil) {
+    if (group.ranExampleCount >= group.exampleCount) {
+      group.ranExampleCount = 0;
+    }
+    group = group.parent;
+  }
+}
+
+- (void)incrementRanExampleCount {
+  SPTExampleGroup *group = self;
+  while (group != nil) {
+    group.ranExampleCount ++;
+    group = group.parent;
+  }
+}
+
+- (void)addBeforeAllBlock:(SPTVoidBlock)block {
+  if (!block) return;
+  [self.beforeAllArray addObject:[block copy]];
+}
+
+- (void)addAfterAllBlock:(SPTVoidBlock)block {
+  if (!block) return;
+  [self.afterAllArray addObject:[block copy]];
+}
+
+- (void)addBeforeEachBlock:(SPTVoidBlock)block {
+  if (!block) return;
+  [self.beforeEachArray addObject:[block copy]];
+}
+
+- (void)addAfterEachBlock:(SPTVoidBlock)block {
+  if (!block) return;
+  [self.afterEachArray addObject:[block copy]];
+}
+
+- (void)runGlobalBeforeEachHooks:(NSString *)compiledName {
+  static NSArray *globalBeforeEachClasses;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    globalBeforeEachClasses = ClassesWithClassMethod(@selector(beforeEach));
+  });
+
+  for (Class class in globalBeforeEachClasses) {
+    [class beforeEach];
+  }
+}
+
+- (void)runGlobalAfterEachHooks:(NSString *)compiledName {
+  static NSArray *globalAfterEachClasses;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    globalAfterEachClasses = ClassesWithClassMethod(@selector(afterEach));
+  });
+
+  for (Class class in globalAfterEachClasses) {
+    [class afterEach];
+  }
+}
+
+- (void)runBeforeHooks:(NSString *)compiledName {
+  NSMutableArray *groups = [NSMutableArray array];
+  SPTExampleGroup *group = self;
+  while (group != nil) {
+    [groups insertObject:group atIndex:0];
+    group = group.parent;
+  }
+
+  // run beforeAll hooks
+  for(group in groups) {
+    if (group.ranExampleCount == 0) {
+      for(id beforeAllBlock in group.beforeAllArray) {
+        runExampleBlock(beforeAllBlock, [NSString stringWithFormat:@"%@ - before all block", compiledName]);
+      }
+    }
+  }
+
+  // run beforeEach hooks
+  [self runGlobalBeforeEachHooks:compiledName];
+  for(group in groups) {
+    for(id beforeEachBlock in group.beforeEachArray) {
+      runExampleBlock(beforeEachBlock, [NSString stringWithFormat:@"%@ - before each block", compiledName]);
+    }
+  }
+}
+
+- (void)runAfterHooks:(NSString *)compiledName {
+  NSMutableArray *groups = [NSMutableArray array];
+  SPTExampleGroup *group = self;
+  while (group != nil) {
+    [groups addObject:group];
+    group = group.parent;
+  }
+  // run afterEach hooks
+  for(group in groups) {
+    for(id afterEachBlock in group.afterEachArray) {
+      runExampleBlock(afterEachBlock, [NSString stringWithFormat:@"%@ - after each block", compiledName]);
+    }
+  }
+  [self runGlobalAfterEachHooks:compiledName];
+
+  // run afterAll hooks
+  for(group in groups) {
+    if (group.ranExampleCount == group.exampleCount) {
+      for(id afterAllBlock in group.afterAllArray) {
+        runExampleBlock(afterAllBlock, [NSString stringWithFormat:@"%@ - after all block", compiledName]);
+      }
+    }
+  }
+}
+
+- (BOOL)isFocusedOrHasFocusedAncestor {
+  SPTExampleGroup *ancestor = self;
+  while (ancestor != nil) {
+    if (ancestor.focused) {
+      return YES;
+    } else {
+      ancestor = ancestor.parent;
+    }
+  }
+
+  return NO;
+}
+
+- (NSArray *)compileExamplesWithNameStack:(NSArray *)nameStack {
+  BOOL groupIsFocusedOrHasFocusedAncestor = [self isFocusedOrHasFocusedAncestor];
+
+  NSArray *compiled = @[];
+  for(id child in self.children) {
+    if ([child isKindOfClass:[SPTExampleGroup class]]) {
+      SPTExampleGroup *group = child;
+      NSArray *newNameStack = [nameStack arrayByAddingObject:group.name];
+      compiled = [compiled arrayByAddingObjectsFromArray:[group compileExamplesWithNameStack:newNameStack]];
+    } else if ([child isKindOfClass:[SPTExample class]]) {
+      SPTExample *example = child;
+      NSArray *newNameStack = [nameStack arrayByAddingObject:example.name];
+      NSString *compiledName = [newNameStack componentsJoinedByString:@" "];
+
+      SPTVoidBlock compiledBlock = example.pending ? nil : ^{
+        @synchronized(self.root) {
+          [self resetRanExampleCountIfNeeded];
+          [self runBeforeHooks:compiledName];
+        }
+        @try {
+          runExampleBlock(example.block, compiledName);
+        }
+        @finally {
+          @synchronized(self.root) {
+            [self incrementRanExampleCount];
+            [self runAfterHooks:compiledName];
+          }
+        }
+      };
+      SPTExample *compiledExample = [[SPTExample alloc] initWithName:compiledName block:compiledBlock];
+      compiledExample.pending = example.pending;
+      compiledExample.focused = (groupIsFocusedOrHasFocusedAncestor || example.focused);
+      compiled = [compiled arrayByAddingObject:compiledExample];
+    }
+  }
+  return compiled;
+}
+
+@end

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

@@ -0,0 +1,5 @@
+#import "SPTReporter.h"
+
+@interface SPTNestedReporter : SPTReporter
+
+@end

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

@@ -0,0 +1,194 @@
+#import "SPTNestedReporter.h"
+#import "XCTestRun+Specta.h"
+
+@interface SPTNestedReporter ()
+
+@property (readwrite, assign, nonatomic) NSInteger nestingLevel;
+@property (readwrite, assign, nonatomic) BOOL indentationEnabled;
+
+@end
+
+@implementation SPTNestedReporter
+
+#pragma mark - Printing
+
+- (NSString *)indentation {
+  // XCode does not strip whitespace from the beginning of lines that report an error. Indentation should only enabled for non-error text.
+
+  if (self.indentationEnabled) {
+    return [@"" stringByPaddingToLength:(self.nestingLevel * 2)
+                             withString:@" "
+                        startingAtIndex:0];
+  } else {
+    return @"";
+  }
+}
+
+- (void)withIndentationEnabled:(void(^)(void))block {
+  [self withIndentationEnabled:YES block:block];
+}
+
+- (void)withIndentationEnabled:(BOOL)indentationEnabled block:(void(^)(void))block {
+  BOOL originalValue = self.indentationEnabled;
+
+  self.indentationEnabled = indentationEnabled;
+  @try {
+    block();
+  } @finally {
+    self.indentationEnabled = originalValue;
+  }
+}
+
+- (void)printIndentation {
+  [self printString:self.indentation];
+}
+
+- (void)printTestSuiteHeader:(XCTestRun *)testRun {
+  [self printIndentation];
+  [self printLineWithFormat:@"= %@", testRun.test.name];
+}
+
+- (void)printTestSuiteFooter:(XCTestRun *)testRun {
+  [self printIndentation];
+  [self printLine];
+
+  if (self.nestingLevel == 0) {
+    [self printConciseSummaryOfTestRun:testRun];
+  }
+}
+
+- (void)printConciseSummaryOfTestRun:(XCTestRun *)testRun {
+  NSUInteger numberOfTests = testRun.testCaseCount;
+  NSUInteger numberOfFailures = testRun.totalFailureCount;
+  NSUInteger numberOfExceptions = testRun.unexpectedExceptionCount;
+  NSUInteger numberOfSkippedTests = testRun.spt_skippedTestCaseCount;
+  NSUInteger numberOfPendingTests = testRun.spt_pendingTestCaseCount;
+
+  NSString * runInfo = [[self class] conciseRunInfoWithNumberOfTests:numberOfTests
+                                                numberOfSkippedTests:numberOfSkippedTests
+                                                    numberOfFailures:numberOfFailures
+                                                  numberOfExceptions:numberOfExceptions
+                                                numberOfPendingTests:numberOfPendingTests];
+
+  [self printIndentation];
+  [self printLine:runInfo];
+}
+
+- (void)printTestCaseHeader:(XCTestRun *)testRun {
+  [self printIndentation];
+  [self printLineWithFormat:@"%@", testRun.test.name];
+}
+
+- (void)printTestCaseFooter:(XCTestRun *)testRun {
+  [self printIndentation];
+  [self printLine];
+}
+
++ (NSString *)pluralizeString:(NSString *)singularString
+                 pluralString:(NSString *)pluralString
+                        count:(NSInteger)count {
+  return (count == 1 || count == -1) ? singularString : pluralString;
+}
+
++ (NSString *)conciseRunInfoWithNumberOfTests:(NSUInteger)numberOfTests
+                         numberOfSkippedTests:(NSUInteger)numberOfSkippedTests
+                             numberOfFailures:(NSUInteger)numberOfFailures
+                           numberOfExceptions:(NSUInteger)numberOfExceptions
+                         numberOfPendingTests:(NSUInteger)numberOfPendingTests {
+  NSString * testLabel = [[self class] pluralizeString:@"test"
+                                          pluralString:@"tests"
+                                                 count:numberOfTests];
+
+  NSString * failureLabel = [[self class] pluralizeString:@"failure"
+                                             pluralString:@"failures"
+                                                    count:numberOfFailures];
+
+  NSString * exceptionLabel = [[self class] pluralizeString:@"exception"
+                                               pluralString:@"exceptions"
+                                                      count:numberOfExceptions];
+
+  return [NSString stringWithFormat:@"%lu %@; %lu skipped; %lu %@; %lu %@; %lu pending",
+                                    (unsigned long)numberOfTests,
+                                    testLabel,
+                                    (unsigned long)numberOfSkippedTests,
+                                    (unsigned long)numberOfFailures,
+                                    failureLabel,
+                                    (unsigned long)numberOfExceptions,
+                                    exceptionLabel,
+                                    (unsigned long)numberOfPendingTests];
+}
+
+#pragma mark - XCTestObserver
+
+- (void)startObserving {
+  [super startObserving];
+
+  self.nestingLevel = 0;
+}
+
+- (void)testSuiteDidStart:(XCTestRun *)testRun {
+  [self withIndentationEnabled:^{
+
+    [self printTestSuiteHeader:testRun];
+    self.nestingLevel ++;
+
+    [super testSuiteDidStart:testRun];
+    [self printLine];
+
+  }];
+}
+
+- (void)testSuiteDidStop:(XCTestRun *)testRun {
+  [self withIndentationEnabled:^{
+
+    [super testSuiteDidStop:testRun];
+
+    self.nestingLevel --;
+    [self printTestSuiteFooter:testRun];
+
+  }];
+}
+
+- (void)testCaseDidStart:(XCTestRun *)testRun {
+  [self withIndentationEnabled:^{
+
+    [self printTestCaseHeader:testRun];
+    self.nestingLevel ++;
+
+    [super testCaseDidStart:testRun];
+
+  }];
+}
+
+- (void)testCaseDidStop:(XCTestRun *)testRun {
+  [self withIndentationEnabled:^{
+
+    [super testCaseDidStop:testRun];
+
+    self.nestingLevel --;
+    [self printTestCaseFooter:testRun];
+
+  }];
+}
+
+- (void)testLogWithFormat:(NSString *)format arguments:(va_list)arguments {
+  NSString * indentation = self.indentation;
+
+  NSMutableString * indentedFormat = [[NSMutableString alloc] initWithString:format];
+  [indentedFormat insertString:indentation atIndex:0];
+
+  NSRange replacementRange = NSMakeRange(0, [indentedFormat length]);
+  if ([indentedFormat hasSuffix:@"\n"]) {
+    replacementRange.length -= [@"\n" length];
+  }
+
+  [indentedFormat replaceOccurrencesOfString:@"\n"
+                                  withString:[@"\n" stringByAppendingString:indentation]
+                                     options:0
+                                       range:replacementRange];
+
+  [super testLogWithFormat:indentedFormat
+                 arguments:arguments];
+}
+
+@end

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

@@ -0,0 +1,33 @@
+#import <XCTest/XCTest.h>
+
+@interface SPTReporter : XCTestLog
+
+/*
+ * Returns a singleton reporter used to generate Specta's test output.
+ * The type of reporter can be customized by subclassing and setting the
+ * SPECTA_REPORTER_CLASS environment variable.
+ *
+ * Subclasses may override methods from XCTestObserver to change test output.
+ * Initialization shuld be performed in the -startObserving / -stopObserving methods,
+ * and MUST invoke the super class implementation.
+ */
++ (instancetype)sharedReporter;
+
+#pragma mark - Run Stack
+
+@property (nonatomic, strong, readonly) NSArray *runStack;
+@property (nonatomic, assign, readonly) NSUInteger runStackCount;
+
+@property (nonatomic, assign, readonly) NSInteger numberOfTestCases;
+@property (nonatomic, assign, readonly) NSInteger numberOfCompletedTestCases;
+
+#pragma mark - Printing
+
+- (void)printString:(NSString *)string;
+- (void)printStringWithFormat:(NSString *)formatString, ... NS_FORMAT_FUNCTION(1,2);
+
+- (void)printLine;
+- (void)printLine:(NSString *)line;
+- (void)printLineWithFormat:(NSString *)formatString, ... NS_FORMAT_FUNCTION(1,2);
+
+@end

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

@@ -0,0 +1,134 @@
+#import "SPTReporter.h"
+#import "SPTNestedReporter.h"
+#import "XCTestLog+Specta.h"
+
+@interface SPTReporter ()
+
+@property (nonatomic, strong, readwrite) NSArray *runStack;
+@property (nonatomic, assign, readwrite) NSInteger numberOfCompletedTestCases;
+
+@end
+
+@implementation SPTReporter
+
++ (instancetype)sharedReporter {
+  static SPTReporter * sharedReporter;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedReporter = [self loadSharedReporter];
+  });
+
+  return sharedReporter;
+}
+
++ (SPTReporter *)loadSharedReporter {
+  NSString * customReporterClassName = [[NSProcessInfo processInfo] environment][@"SPECTA_REPORTER_CLASS"];
+  if (customReporterClassName != nil) {
+    Class customReporterClass = NSClassFromString(customReporterClassName);
+    if (customReporterClass != nil) {
+      return [[customReporterClass alloc] init];
+    }
+  }
+
+  return [[SPTNestedReporter alloc] init];
+}
+
+#pragma mark - Run Stack
+
+- (NSUInteger)runStackCount {
+  return self.runStack.count;
+}
+
+- (void)pushRunStack:(XCTestRun *)run {
+  [(NSMutableArray *)self.runStack addObject:run];
+}
+
+- (void)popRunStack:(XCTestRun *)run {
+  NSAssert(run != nil, @"Attempt to pop nil test run");
+
+  NSAssert([self.runStack lastObject] == run,
+           @"Attempt to pop test run (%@) out of order: %@",
+           run,
+           self.runStack);
+
+  [(NSMutableArray *)self.runStack removeLastObject];
+}
+
+- (NSInteger)numberOfTestCases {
+  XCTestRun * rootRun = self.runStack.firstObject;
+  if (rootRun) {
+    return rootRun.testCaseCount;
+  } else {
+    return 0;
+  }
+}
+
+#pragma mark - Printing
+
+- (void)printString:(NSString *)string {
+  [[self logFileHandle] writeData:[string dataUsingEncoding:NSUTF8StringEncoding]];
+}
+
+- (void)printStringWithFormat:(NSString *)formatString, ... {
+  va_list args;
+  va_start(args, formatString);
+  NSString * formattedString = [[NSString alloc] initWithFormat:formatString arguments:args];
+  va_end(args);
+
+  [self printString:formattedString];
+}
+
+- (void)printLine {
+  [self printString:@"\n"];
+}
+
+- (void)printLine:(NSString *)line {
+  [self printStringWithFormat:@"%@\n", line];
+}
+
+- (void)printLineWithFormat:(NSString *)formatString, ... {
+  va_list args;
+  va_start(args, formatString);
+  NSString * formattedString = [[NSString alloc] initWithFormat:formatString arguments:args];
+  va_end(args);
+
+  [self printLine:formattedString];
+}
+
+#pragma mark - XCTestObserver
+
+- (void)startObserving {
+  [super startObserving];
+
+  self.runStack = [[NSMutableArray alloc] init];
+}
+
+- (void)stopObserving {
+  [super stopObserving];
+
+  self.runStack = nil;
+}
+
+- (void)testSuiteDidStart:(XCTestRun *)testRun {
+  [super testSuiteDidStart:testRun];
+  [self pushRunStack:testRun];
+}
+
+- (void)testSuiteDidStop:(XCTestRun *)testRun {
+  [super testSuiteDidStop:testRun];
+  [self popRunStack:testRun];
+}
+
+- (void)testCaseDidStart:(XCTestRun *)testRun {
+  [super testCaseDidStart:testRun];
+  [self pushRunStack:testRun];
+}
+
+- (void)testCaseDidStop:(XCTestRun *)testRun {
+  [super testCaseDidStop:testRun];
+  [self popRunStack:testRun];
+
+  self.numberOfCompletedTestCases++;
+}
+
+@end

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

@@ -0,0 +1,17 @@
+#import <Foundation/Foundation.h>
+#import "SpectaTypes.h"
+
+@class
+  SPTExampleGroup
+;
+
+@interface SPTSharedExampleGroups : NSObject
+
++ (void)addSharedExampleGroupWithName:(NSString *)name block:(SPTDictionaryBlock)block exampleGroup:(SPTExampleGroup *)exampleGroup;
++ (SPTDictionaryBlock)sharedExampleGroupWithName:(NSString *)name exampleGroup:(SPTExampleGroup *)exampleGroup;
++ (void)defineSharedExampleGroups;
+
++ (void)recordFailureWithDescription:(NSString *)description inFile:(NSString *)filename atLine:(NSUInteger)lineNumber expected:(BOOL)expected;
+
+@end
+