initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/FBSnapshotTestCase.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import <QuartzCore/QuartzCore.h>
+
+#import <UIKit/UIKit.h>
+
+#import <XCTest/XCTest.h>
+
+#ifndef FB_REFERENCE_IMAGE_DIR
+#define FB_REFERENCE_IMAGE_DIR "\"$(SOURCE_ROOT)/$(PROJECT_NAME)Tests/ReferenceImages\""
+#endif
+
+/**
+ The base class of view snapshotting tests. If you have small UI component, it's often easier to configure it in a test
+ and compare an image of the view to a reference image that write lots of complex layout-code tests.
+
+ In order to flip the tests in your subclass to record the reference images set `recordMode` to YES before calling
+ -[super setUp].
+ */
+@interface FBSnapshotTestCase : XCTestCase
+
+/**
+ When YES, the test macros will save reference images, rather than performing an actual test.
+ */
+@property (readwrite, nonatomic, assign) BOOL recordMode;
+
+/**
+ Performs the comparisons or records a snapshot of the view if recordMode is YES.
+ @param view The view to snapshot
+ @param referenceImagesDirectory The directory in which reference images are stored.
+ @param identifier An optional identifier, used if there are multiple snapshot tests in a given -test method.
+ @param error An error to log in an XCTAssert() macro if the method fails (missing reference image, images differ, etc).
+ @returns YES if the comparison (or saving of the reference image) succeeded.
+ */
+- (BOOL)compareSnapshotOfView:(UIView *)view
+     referenceImagesDirectory:(NSString *)referenceImagesDirectory
+                   identifier:(NSString *)identifier
+                        error:(NSError **)errorPtr;
+
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/FBSnapshotTestCase.m

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import "FBSnapshotTestCase.h"
+
+#import "FBSnapshotTestController.h"
+
+@interface FBSnapshotTestCase ()
+
+@property (readwrite, nonatomic, retain) FBSnapshotTestController *snapshotController;
+
+@end
+
+@implementation FBSnapshotTestCase
+
+- (void)setUp
+{
+  [super setUp];
+  self.snapshotController = [[FBSnapshotTestController alloc] initWithTestName:NSStringFromClass([self class])];
+}
+
+- (void)tearDown
+{
+  self.snapshotController = nil;
+  [super tearDown];
+}
+
+- (BOOL)recordMode
+{
+  return self.snapshotController.recordMode;
+}
+
+- (void)setRecordMode:(BOOL)recordMode
+{
+  self.snapshotController.recordMode = recordMode;
+}
+
+- (BOOL)compareSnapshotOfView:(UIView *)view
+     referenceImagesDirectory:(NSString *)referenceImagesDirectory
+                   identifier:(NSString *)identifier
+                        error:(NSError **)errorPtr
+{
+  _snapshotController.referenceImagesDirectory = referenceImagesDirectory;
+  return [_snapshotController compareSnapshotOfView:view
+                                           selector:self.invocation.selector
+                                         identifier:identifier
+                                              error:errorPtr];
+}
+
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/FBSnapshotTestController.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+typedef NS_ENUM(NSInteger, FBSnapshotTestControllerErrorCode) {
+  FBSnapshotTestControllerErrorCodeUnknown,
+  FBSnapshotTestControllerErrorCodeNeedsRecord,
+  FBSnapshotTestControllerErrorCodePNGCreationFailed,
+  FBSnapshotTestControllerErrorCodeImagesDifferentSizes,
+  FBSnapshotTestControllerErrorCodeImagesDifferent,
+};
+/**
+ Errors returned by the methods of FBSnapshotTestController use this domain.
+ */
+extern NSString *const FBSnapshotTestControllerErrorDomain;
+
+/**
+ Errors returned by the methods of FBSnapshotTestController sometimes contain this key in the `userInfo` dictionary.
+ */
+extern NSString *const FBReferenceImageFilePathKey;
+
+/**
+ Provides the heavy-lifting for FBSnapshotTestCase. It loads and saves images, along with performing the actual pixel-
+ by-pixel comparison of images.
+ Instances are initialized with the test class, and directories to read and write to.
+ */
+@interface FBSnapshotTestController : NSObject
+
+/**
+ Record snapshots.
+ **/
+@property(readwrite, nonatomic, assign) BOOL recordMode;
+
+/**
+ @param testClass The subclass of FBSnapshotTestCase that is using this controller.
+ @returns An instance of FBSnapshotTestController.
+ */
+- (id)initWithTestClass:(Class)testClass;
+
+/**
+ Designated initializer.
+ @param testName The name of the tests.
+ @returns An instance of FBSnapshotTestController.
+ */
+- (id)initWithTestName:(NSString *)testName;
+
+/**
+ Performs the comparison of the view.
+ @param view The view to snapshot.
+ @param selector selector
+ @param identifier An optional identifier, used is there are muliptle snapshot tests in a given -test method.
+ @param errorPtr An error to log in an XCTAssert() macro if the method fails (missing reference image, images differ, etc).
+ @returns YES if the comparison (or saving of the reference image) succeeded.
+ */
+- (BOOL)compareSnapshotOfView:(UIView *)view
+                     selector:(SEL)selector
+                   identifier:(NSString *)identifier
+                        error:(NSError **)errorPtr;
+
+/**
+ The directory in which reference images are stored.
+ */
+@property (readwrite, nonatomic, copy) NSString *referenceImagesDirectory;
+
+/**
+ Loads a reference image.
+ @param selector The test method being run.
+ @param identifier The optional identifier, used when multiple images are tested in a single -test method.
+ @param error An error, if this methods returns nil, the error will be something useful.
+ @returns An image.
+ */
+- (UIImage *)referenceImageForSelector:(SEL)selector
+                            identifier:(NSString *)identifier
+                                 error:(NSError **)error;
+
+/**
+ Saves a reference image.
+ @param selector The test method being run.
+ @param identifier The optional identifier, used when multiple images are tested in a single -test method.
+ @param errorPtr An error, if this methods returns NO, the error will be something useful.
+ @returns An image.
+ */
+- (BOOL)saveReferenceImage:(UIImage *)image
+                  selector:(SEL)selector
+                identifier:(NSString *)identifier
+                     error:(NSError **)errorPtr;
+
+/**
+ Performs a pixel-by-pixel comparison of the two images.
+ @param referenceImage The reference (correct) image.
+ @param image The image to test against the reference.
+ @param errorPtr An error that indicates why the comparison failed if it does.
+ @returns YES if the comparison succeeded and the images are the same.
+ */
+- (BOOL)compareReferenceImage:(UIImage *)referenceImage
+                      toImage:(UIImage *)image
+                        error:(NSError **)errorPtr;
+
+/**
+ Saves the reference image and the test image to `failedOutputDirectory`.
+ @param referenceImage The reference (correct) image.
+ @param testImage The image to test against the reference.
+ @param selector The test method being run.
+ @param identifier The optional identifier, used when multiple images are tested in a single -test method.
+ @param errorPtr An error that indicates why the comparison failed if it does.
+ @returns YES if the save succeeded.
+ */
+- (BOOL)saveFailedReferenceImage:(UIImage *)referenceImage
+                       testImage:(UIImage *)testImage
+                        selector:(SEL)selector
+                      identifier:(NSString *)identifier
+                           error:(NSError **)errorPtr;
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/FBSnapshotTestController.m

@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import "FBSnapshotTestController.h"
+
+#import <objc/runtime.h>
+
+#import <UIKit/UIKit.h>
+
+#import "UIImage+Compare.h"
+#import "UIImage+Diff.h"
+
+NSString *const FBSnapshotTestControllerErrorDomain = @"FBSnapshotTestControllerErrorDomain";
+
+NSString *const FBReferenceImageFilePathKey = @"FBReferenceImageFilePathKey";
+
+typedef struct RGBAPixel {
+  char r;
+  char g;
+  char b;
+  char a;
+} RGBAPixel;
+
+@interface FBSnapshotTestController ()
+
+@property (readonly, nonatomic, copy) NSString *testName;
+
+@end
+
+@implementation FBSnapshotTestController
+{
+  NSFileManager *_fileManager;
+}
+
+#pragma mark - Lifecycle
+
+- (instancetype)initWithTestClass:(Class)testClass;
+{
+    return [self initWithTestName:NSStringFromClass(testClass)];
+}
+
+- (instancetype)initWithTestName:(NSString *)testName
+{
+    if ((self = [super init])) {
+        _testName = [testName copy];
+        _fileManager = [NSFileManager new];
+    }
+    return self;
+}
+
+#pragma mark - Properties
+
+- (NSString *)description
+{
+  return [NSString stringWithFormat:@"%@ %@", [super description], _referenceImagesDirectory];
+}
+
+#pragma mark - Public API
+
+- (UIImage *)referenceImageForSelector:(SEL)selector
+                            identifier:(NSString *)identifier
+                                 error:(NSError **)errorPtr
+{
+  NSString *filePath = [self _referenceFilePathForSelector:selector identifier:identifier];
+  UIImage *image = [UIImage imageWithContentsOfFile:filePath];
+  if (nil == image && NULL != errorPtr) {
+    BOOL exists = [_fileManager fileExistsAtPath:filePath];
+    if (!exists) {
+      *errorPtr = [NSError errorWithDomain:FBSnapshotTestControllerErrorDomain
+                                      code:FBSnapshotTestControllerErrorCodeNeedsRecord
+                                  userInfo:@{
+               FBReferenceImageFilePathKey: filePath,
+                 NSLocalizedDescriptionKey: @"Unable to load reference image.",
+          NSLocalizedFailureReasonErrorKey: @"Reference image not found. You need to run the test in record mode",
+                   }];
+    } else {
+      *errorPtr = [NSError errorWithDomain:FBSnapshotTestControllerErrorDomain
+                                      code:FBSnapshotTestControllerErrorCodeUnknown
+                                  userInfo:nil];
+    }
+  }
+  return image;
+}
+
+- (BOOL)saveReferenceImage:(UIImage *)image
+                  selector:(SEL)selector
+                identifier:(NSString *)identifier
+                     error:(NSError **)errorPtr
+{
+  BOOL didWrite = NO;
+  if (nil != image) {
+    NSString *filePath = [self _referenceFilePathForSelector:selector identifier:identifier];
+    NSData *pngData = UIImagePNGRepresentation(image);
+    if (nil != pngData) {
+      NSError *creationError = nil;
+      BOOL didCreateDir = [_fileManager createDirectoryAtPath:[filePath stringByDeletingLastPathComponent]
+                                  withIntermediateDirectories:YES
+                                                   attributes:nil
+                                                        error:&creationError];
+      if (!didCreateDir) {
+        if (NULL != errorPtr) {
+          *errorPtr = creationError;
+        }
+        return NO;
+      }
+      didWrite = [pngData writeToFile:filePath options:NSDataWritingAtomic error:errorPtr];
+      if (didWrite) {
+        NSLog(@"Reference image save at: %@", filePath);
+      }
+    } else {
+      if (nil != errorPtr) {
+        *errorPtr = [NSError errorWithDomain:FBSnapshotTestControllerErrorDomain
+                                        code:FBSnapshotTestControllerErrorCodePNGCreationFailed
+                                    userInfo:@{
+                 FBReferenceImageFilePathKey: filePath,
+                     }];
+      }
+    }
+  }
+  return didWrite;
+}
+
+- (BOOL)saveFailedReferenceImage:(UIImage *)referenceImage
+                       testImage:(UIImage *)testImage
+                        selector:(SEL)selector
+                      identifier:(NSString *)identifier
+                           error:(NSError **)errorPtr
+{
+  NSData *referencePNGData = UIImagePNGRepresentation(referenceImage);
+  NSData *testPNGData = UIImagePNGRepresentation(testImage);
+
+  NSString *referencePath = [self _failedFilePathForSelector:selector
+                                                  identifier:identifier
+                                                fileNameType:FBTestSnapshotFileNameTypeFailedReference];
+
+  NSError *creationError = nil;
+  BOOL didCreateDir = [_fileManager createDirectoryAtPath:[referencePath stringByDeletingLastPathComponent]
+                              withIntermediateDirectories:YES
+                                               attributes:nil
+                                                    error:&creationError];
+  if (!didCreateDir) {
+    if (NULL != errorPtr) {
+      *errorPtr = creationError;
+    }
+    return NO;
+  }
+
+  if (![referencePNGData writeToFile:referencePath options:NSDataWritingAtomic error:errorPtr]) {
+    return NO;
+  }
+
+  NSString *testPath = [self _failedFilePathForSelector:selector
+                                             identifier:identifier
+                                           fileNameType:FBTestSnapshotFileNameTypeFailedTest];
+
+  if (![testPNGData writeToFile:testPath options:NSDataWritingAtomic error:errorPtr]) {
+    return NO;
+  }
+
+  NSString *diffPath = [self _failedFilePathForSelector:selector
+                                               identifier:identifier
+                                             fileNameType:FBTestSnapshotFileNameTypeFailedTestDiff];
+
+  UIImage *diffImage = [referenceImage diffWithImage:testImage];
+  NSData *diffImageData = UIImagePNGRepresentation(diffImage);
+
+  if (![diffImageData writeToFile:diffPath options:NSDataWritingAtomic error:errorPtr]) {
+    return NO;
+  }
+
+  NSLog(@"If you have Kaleidoscope installed you can run this command to see an image diff:\n"
+        @"ksdiff \"%@\" \"%@\"", referencePath, testPath);
+
+  return YES;
+}
+
+- (BOOL)compareReferenceImage:(UIImage *)referenceImage toImage:(UIImage *)image error:(NSError **)errorPtr
+{
+  if (CGSizeEqualToSize(referenceImage.size, image.size)) {
+
+    BOOL imagesEqual = [referenceImage compareWithImage:image];
+    if (NULL != errorPtr) {
+      *errorPtr = [NSError errorWithDomain:FBSnapshotTestControllerErrorDomain
+                                      code:FBSnapshotTestControllerErrorCodeImagesDifferent
+                                  userInfo:@{
+                 NSLocalizedDescriptionKey: @"Images different",
+                   }];
+    }
+    return imagesEqual;
+  }
+  if (NULL != errorPtr) {
+    *errorPtr = [NSError errorWithDomain:FBSnapshotTestControllerErrorDomain
+                                    code:FBSnapshotTestControllerErrorCodeImagesDifferentSizes
+                                userInfo:@{
+               NSLocalizedDescriptionKey: @"Images different sizes",
+        NSLocalizedFailureReasonErrorKey: [NSString stringWithFormat:@"referenceImage:%@, image:%@",
+                                           NSStringFromCGSize(referenceImage.size),
+                                           NSStringFromCGSize(image.size)],
+                 }];
+  }
+  return NO;
+}
+
+#pragma mark - Private API
+
+typedef NS_ENUM(NSUInteger, FBTestSnapshotFileNameType) {
+  FBTestSnapshotFileNameTypeReference,
+  FBTestSnapshotFileNameTypeFailedReference,
+  FBTestSnapshotFileNameTypeFailedTest,
+  FBTestSnapshotFileNameTypeFailedTestDiff,
+};
+
+- (NSString *)_fileNameForSelector:(SEL)selector
+                        identifier:(NSString *)identifier
+                      fileNameType:(FBTestSnapshotFileNameType)fileNameType
+{
+  NSString *fileName = nil;
+  switch (fileNameType) {
+    case FBTestSnapshotFileNameTypeFailedReference:
+      fileName = @"reference_";
+      break;
+    case FBTestSnapshotFileNameTypeFailedTest:
+      fileName = @"failed_";
+      break;
+    case FBTestSnapshotFileNameTypeFailedTestDiff:
+      fileName = @"diff_";
+      break;
+    default:
+      fileName = @"";
+      break;
+  }
+  fileName = [fileName stringByAppendingString:NSStringFromSelector(selector)];
+  if (0 < identifier.length) {
+    fileName = [fileName stringByAppendingFormat:@"_%@", identifier];
+  }
+  if ([[UIScreen mainScreen] scale] > 1.0) {
+    fileName = [fileName stringByAppendingFormat:@"@%.fx", [[UIScreen mainScreen] scale]];
+  }
+#if TARGET_OS_TV
+  fileName = [fileName stringByAppendingString:@"_tvOS"];
+#endif
+  fileName = [fileName stringByAppendingPathExtension:@"png"];
+  return fileName;
+}
+
+- (NSString *)_referenceFilePathForSelector:(SEL)selector identifier:(NSString *)identifier
+{
+  NSString *fileName = [self _fileNameForSelector:selector
+                                       identifier:identifier
+                                     fileNameType:FBTestSnapshotFileNameTypeReference];
+  NSString *filePath = [_referenceImagesDirectory stringByAppendingPathComponent:_testName];
+  filePath = [filePath stringByAppendingPathComponent:fileName];
+  return filePath;
+}
+
+- (NSString *)_failedFilePathForSelector:(SEL)selector
+                              identifier:(NSString *)identifier
+                            fileNameType:(FBTestSnapshotFileNameType)fileNameType
+{
+  NSString *fileName = [self _fileNameForSelector:selector
+                                       identifier:identifier
+                                     fileNameType:fileNameType];
+  NSString *folderPath = NSTemporaryDirectory();
+  if (getenv("IMAGE_DIFF_DIR")) {
+    folderPath = @(getenv("IMAGE_DIFF_DIR"));
+  }
+  NSString *filePath = [folderPath stringByAppendingPathComponent:_testName];
+  filePath = [filePath stringByAppendingPathComponent:fileName];
+  return filePath;
+}
+
+- (BOOL)compareSnapshotOfView:(id)view
+                     selector:(SEL)selector
+                   identifier:(NSString *)identifier
+                        error:(NSError **)errorPtr
+{
+  if (self.recordMode) {
+    return [self _recordSnapshotOfView:view selector:selector identifier:identifier error:errorPtr];
+  } else {
+    return [self _performPixelComparisonWithView:view selector:selector identifier:identifier error:errorPtr];
+  }
+}
+
+#pragma mark - Private API
+
+- (BOOL)_performPixelComparisonWithView:(UIView *)view
+                               selector:(SEL)selector
+                             identifier:(NSString *)identifier
+                                  error:(NSError **)errorPtr
+{
+  UIImage *referenceImage = [self referenceImageForSelector:selector identifier:identifier error:errorPtr];
+  if (nil != referenceImage) {
+    UIImage *snapshot = [self _snapshotView:view];
+    BOOL imagesSame = [self compareReferenceImage:referenceImage toImage:snapshot error:errorPtr];
+    if (!imagesSame) {
+      [self saveFailedReferenceImage:referenceImage
+                           testImage:snapshot
+                            selector:selector
+                          identifier:identifier
+                               error:errorPtr];
+    }
+    return imagesSame;
+  }
+  return NO;
+}
+
+- (BOOL)_recordSnapshotOfView:(UIView *)view
+                     selector:(SEL)selector
+                   identifier:(NSString *)identifier
+                        error:(NSError **)errorPtr
+{
+  UIImage *snapshot = [self _snapshotView:view];
+  return [self saveReferenceImage:snapshot selector:selector identifier:identifier error:errorPtr];
+}
+
+- (UIImage *)_snapshotView:(UIView *)view
+{
+  [view layoutIfNeeded];
+
+  CGRect bounds = view.bounds;
+
+  NSAssert1(CGRectGetWidth(bounds), @"Zero width for view %@", view);
+  NSAssert1(CGRectGetHeight(bounds), @"Zero height for view %@", view);
+
+  UIGraphicsBeginImageContextWithOptions(bounds.size, NO, 0);
+  CGContextRef context = UIGraphicsGetCurrentContext();
+  NSAssert1(context, @"Could not generate context for view %@", view);
+
+  UIGraphicsPushContext(context);
+  CGContextSaveGState(context);
+  {
+    BOOL success = [view drawViewHierarchyInRect:bounds afterScreenUpdates:YES];
+    NSAssert1(success, @"Could not create snapshot for view %@", view);
+  }
+  CGContextRestoreGState(context);
+  UIGraphicsPopContext();
+
+  UIImage *snapshot = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+
+  return snapshot;
+}
+
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/UIImage+Compare.h

@@ -0,0 +1,37 @@
+//
+//  Created by Gabriel Handford on 3/1/09.
+//  Copyright 2009-2013. All rights reserved.
+//  Created by John Boiles on 10/20/11.
+//  Copyright (c) 2011. All rights reserved
+//  Modified by Felix Schulze on 2/11/13.
+//  Copyright 2013. All rights reserved.
+//
+//  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.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface UIImage (Compare)
+
+- (BOOL)compareWithImage:(UIImage *)image;
+
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/UIImage+Compare.m

@@ -0,0 +1,91 @@
+//
+//  Created by Gabriel Handford on 3/1/09.
+//  Copyright 2009-2013. All rights reserved.
+//  Created by John Boiles on 10/20/11.
+//  Copyright (c) 2011. All rights reserved
+//  Modified by Felix Schulze on 2/11/13.
+//  Copyright 2013. All rights reserved.
+//
+//  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.
+//
+
+#import "UIImage+Compare.h"
+
+@implementation UIImage (Compare)
+
+- (BOOL)compareWithImage:(UIImage *)image
+{
+  NSAssert(CGSizeEqualToSize(self.size, image.size), @"Images must be same size.");
+
+  // The images have the equal size, so we could use the smallest amount of bytes because of byte padding
+  size_t minBytesPerRow = MIN(CGImageGetBytesPerRow(self.CGImage), CGImageGetBytesPerRow(image.CGImage));
+  size_t referenceImageSizeBytes = CGImageGetHeight(self.CGImage) * minBytesPerRow;
+  void *referenceImagePixels = calloc(1, referenceImageSizeBytes);
+  void *imagePixels = calloc(1, referenceImageSizeBytes);
+
+  if (!referenceImagePixels || !imagePixels) {
+    free(referenceImagePixels);
+    free(imagePixels);
+    return NO;
+  }
+
+  CGContextRef referenceImageContext = CGBitmapContextCreate(referenceImagePixels,
+                                                             CGImageGetWidth(self.CGImage),
+                                                             CGImageGetHeight(self.CGImage),
+                                                             CGImageGetBitsPerComponent(self.CGImage),
+                                                             minBytesPerRow,
+                                                             CGImageGetColorSpace(self.CGImage),
+                                                             (CGBitmapInfo)kCGImageAlphaPremultipliedLast
+                                                             );
+  CGContextRef imageContext = CGBitmapContextCreate(imagePixels,
+                                                    CGImageGetWidth(image.CGImage),
+                                                    CGImageGetHeight(image.CGImage),
+                                                    CGImageGetBitsPerComponent(image.CGImage),
+                                                    minBytesPerRow,
+                                                    CGImageGetColorSpace(image.CGImage),
+                                                    (CGBitmapInfo)kCGImageAlphaPremultipliedLast
+                                                    );
+
+  CGFloat scaleFactor = [UIScreen mainScreen].scale;
+  CGContextScaleCTM(referenceImageContext, scaleFactor, scaleFactor);
+  CGContextScaleCTM(imageContext, scaleFactor, scaleFactor);
+
+  if (!referenceImageContext || !imageContext) {
+    CGContextRelease(referenceImageContext);
+    CGContextRelease(imageContext);
+    free(referenceImagePixels);
+    free(imagePixels);
+    return NO;
+  }
+
+  CGContextDrawImage(referenceImageContext, CGRectMake(0.0f, 0.0f, self.size.width, self.size.height), self.CGImage);
+  CGContextDrawImage(imageContext, CGRectMake(0.0f, 0.0f, image.size.width, image.size.height), image.CGImage);
+  CGContextRelease(referenceImageContext);
+  CGContextRelease(imageContext);
+
+  BOOL imageEqual = (memcmp(referenceImagePixels, imagePixels, referenceImageSizeBytes) == 0);
+  free(referenceImagePixels);
+  free(imagePixels);
+  return imageEqual;
+}
+
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/UIImage+Diff.h

@@ -0,0 +1,37 @@
+//
+//  Created by Gabriel Handford on 3/1/09.
+//  Copyright 2009-2013. All rights reserved.
+//  Created by John Boiles on 10/20/11.
+//  Copyright (c) 2011. All rights reserved
+//  Modified by Felix Schulze on 2/11/13.
+//  Copyright 2013. All rights reserved.
+//
+//  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.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface UIImage (Diff)
+
+- (UIImage *)diffWithImage:(UIImage *)image;
+
+@end

node_modules/react-native/Libraries/RCTTest/FBSnapshotTestCase/UIImage+Diff.m

@@ -0,0 +1,56 @@
+//
+//  Created by Gabriel Handford on 3/1/09.
+//  Copyright 2009-2013. All rights reserved.
+//  Created by John Boiles on 10/20/11.
+//  Copyright (c) 2011. All rights reserved
+//  Modified by Felix Schulze on 2/11/13.
+//  Copyright 2013. All rights reserved.
+//
+//  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.
+//
+
+#import "UIImage+Diff.h"
+
+@implementation UIImage (Diff)
+
+- (UIImage *)diffWithImage:(UIImage *)image
+{
+  if (!image) {
+    return nil;
+  }
+  CGSize imageSize = CGSizeMake(MAX(self.size.width, image.size.width), MAX(self.size.height, image.size.height));
+  UIGraphicsBeginImageContextWithOptions(imageSize, YES, 0.0);
+  CGContextRef context = UIGraphicsGetCurrentContext();
+  [self drawInRect:CGRectMake(0, 0, self.size.width, self.size.height)];
+  CGContextSetAlpha(context, 0.5f);
+  CGContextBeginTransparencyLayer(context, NULL);
+  [image drawInRect:CGRectMake(0, 0, image.size.width, image.size.height)];
+  CGContextSetBlendMode(context, kCGBlendModeDifference);
+  CGContextSetFillColorWithColor(context,[UIColor whiteColor].CGColor);
+  CGContextFillRect(context, CGRectMake(0, 0, self.size.width, self.size.height));
+  CGContextEndTransparencyLayer(context);
+  UIImage *returnImage = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+  return returnImage;
+}
+
+@end