iut 0.1.0

data/template/project/iUnitTest/iUnitTest/iunittest/UnitTest/GTMSenTestCase.h

@@ -0,0 +1,17 @@
+//
+//  GTMSenTestCase.h
+//  iUnitTest
+//
+//  Created by Katsuyoshi Ito on 09/02/09.
+//  Copyright 2009 ITO SOFT DESIGN Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "IUTTest.h"
+
+
+@interface SenTestCase : IUTTest {
+
+}
+
+@end

data/template/project/iUnitTest/iUnitTest/iunittest/UnitTest/GTMSenTestCase.m

@@ -0,0 +1,15 @@
+//
+//  GTMSenTestCase.m
+//  iUnitTest
+//
+//  Created by Katsuyoshi Ito on 09/02/09.
+//  Copyright 2009 ITO SOFT DESIGN Inc. All rights reserved.
+//
+
+#import "GTMSenTestCase.h"
+
+
+
+@implementation SenTestCase
+
+@end

data/template/project/iUnitTest/iUnitTest/iunittest/UnitTest/IUTAssertion.h

@@ -0,0 +1,135 @@
+//
+//  IUTAssertion.h
+//  iUnitTest
+//
+//  Created by Katsuyoshi Ito on 09/01/16.
+//  Copyright 2009 ITO SOFT DESIGN Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "IUTAssertionInfo.h"
+#import "SenTestAssertion.h"
+
+
+#define ASSERT(value) [self assert:(value) info:IUTASSERTION_INF(nil)]
+
+#define ASSERT_FAIL(m) [self assert:NO info:IUTASSERTION_INF(m)]
+
+#define ASSERT_SAME(_expected, _value) [self assertSame:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_NOT_SAME(_expected, _value) [self assertNotSame:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+
+
+#define ASSERT_EQUAL(_expected, _value) [self assertEqual:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_NOT_EQUAL(_expected, _value) [self assertNotEqual:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+
+#define ASSERT_EQUAL_INT(_expected, _value) [self assertEqualInt:(int)(_value) expected:(int)(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_NOT_EQUAL_INT(_expected, _value) [self assertNotEqualInt:(int)(_value) expected:(int)(_expected) info:IUTASSERTION_INF(nil)]
+
+#define ASSERT_EQUAL_FLOAT(_expected, _value) [self assertEqualFloat:(float)(_value) expected:(float)(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_NOT_EQUAL_FLOAT(_expected, _value) [self assertNotEqualFloat:(float)(_value) expected:(float)(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_EQUAL_FLOAT_DELTA(_expected, _value, _delta) [self assertEqualFloat:(float)(_value) expected:(float)(_expected) delta:(float)_delta info:IUTASSERTION_INF(nil)]
+
+#define ASSERT_EQUAL_DOUBLE(_expected, _value) [self assertEqualDouble:(float)(_value) expected:(float)(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_NOT_EQUAL_DOUBLE(_expected, _value) [self assertNotEqualDouble:(float)(_value) expected:(float)(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_EQUAL_DOUBLE_DELTA(_expected, _value, _delta) [self assertEqualDouble:(float)(_value) expected:(float)(_expected) delta:(float)_delta info:IUTASSERTION_INF(nil)]
+
+
+#define ASSERT_NIL(_value) [self assertNil:(_value) info:IUTASSERTION_INF(nil)]
+#define ASSERT_NOT_NIL(_value) [self assertNotNil:(_value) info:IUTASSERTION_INF(nil)]
+
+
+#define ASSERT_EQUAL_POINT(_expected, _value) [self assertEqualPoint:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_EQUAL_SIZE(_expected, _value) [self assertEqualSize:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+#define ASSERT_EQUAL_RECT(_expected, _value) [self assertEqualRect:(_value) expected:(_expected) info:IUTASSERTION_INF(nil)]
+
+
+#define ASSERT_RAISE(expr) \
+    do { \
+        @try { \
+            {expr;}\
+        } \
+        @catch (id anException) { \
+            assertedCount++; \
+            continue; \
+        } \
+        ASSERT_FAIL(@"exception expected but none was thrown."); \
+    } while(0)
+
+#define ASSERT_NOTHING_RAISED(expr) \
+    do { \
+        @try { \
+            {expr;}\
+            assertedCount++; \
+        } \
+        @catch (id anException) { \
+            ASSERT_FAIL(([NSString stringWithFormat:@"Exception raised:%@", anException])); \
+        } \
+    } while(0)
+
+
+#define ASSERT_EQUAL_LOCALIZED_STRING(_expected, _value) ASSERT_EQUAL(NSLocalizedString(_expected, nil), _value)
+
+#define ASSERT_EQUAL_LOCALIZED_STRING_FROM_TABLE(_expected, _table, _value) ASSERT_EQUAL(NSLocalizedStringFromTable(_expected, _table, nil), _value)
+
+
+#pragma mark -
+#pragma mark helper
+
+#define TEST_IDLE(sel,t) \
+    [self performTest:@selector(_ ## sel) afterDelay:t];\
+}\
+- (void)_ ## sel {\
+
+
+#define SETUP_IDLE(sel,t) \
+    [self performSetUpSequence:@selector(_ ## sel) afterDelay:t];\
+}\
+- (void)_ ## sel {\
+
+
+
+#pragma mark -
+
+extern NSString * const IUTAssertionExceptionName;
+extern NSString * const IUTAssertionErrorExceptionName;
+
+extern NSString * const IUTAssertionInfoKey;
+
+
+@interface IUTAssertion : NSObject {
+    int assertedCount;
+}
+
+@property (readonly) int assertedCount;
+
++ (NSException *)assertionErrorExceptionFrom:(NSException *)exception klass:(Class)klass selectorName:(NSString *)selectorString;
+
+- (void)clearAssertedCount;
+
+- (void)assert:(BOOL)value info:(IUTAssertionInfo *)info;
+
+- (void)assertSame:(id)value expected:(id)expected info:(IUTAssertionInfo *)info;
+- (void)assertNotSame:(id)value expected:(id)expected info:(IUTAssertionInfo *)info;
+
+- (void)assertEqual:(id)value expected:(id)expected info:(IUTAssertionInfo *)info;
+- (void)assertNotEqual:(id)value expected:(id)expected info:(IUTAssertionInfo *)info;
+
+- (void)assertEqualInt:(int)value expected:(int)expected info:(IUTAssertionInfo *)info;
+- (void)assertNotEqualInt:(int)value expected:(int)expected info:(IUTAssertionInfo *)info;
+
+- (void)assertEqualFloat:(float)value expected:(float)expected info:(IUTAssertionInfo *)info;
+- (void)assertNotEqualFloat:(float)value expected:(float)expected info:(IUTAssertionInfo *)info;
+- (void)assertEqualFloat:(float)value expected:(float)expected delta:(float)delta info:(IUTAssertionInfo *)info;
+
+- (void)assertEqualDouble:(double)value expected:(double)expected info:(IUTAssertionInfo *)info;
+- (void)assertNotEqualDouble:(double)value expected:(double)expected info:(IUTAssertionInfo *)info;
+- (void)assertEqualDouble:(double)value expected:(double)expected delta:(double)delta info:(IUTAssertionInfo *)info;
+
+- (void)assertNil:(id)value info:(IUTAssertionInfo *)info;
+- (void)assertNotNil:(id)value info:(IUTAssertionInfo *)info;
+
+- (void)assertEqualPoint:(CGPoint)value expected:(CGPoint)expected info:(IUTAssertionInfo *)info;
+- (void)assertEqualSize:(CGSize)value expected:(CGSize)expected info:(IUTAssertionInfo *)info;
+- (void)assertEqualRect:(CGRect)value expected:(CGRect)expected info:(IUTAssertionInfo *)info;
+
+@end

data/template/project/iUnitTest/iUnitTest/iunittest/UnitTest/IUTAssertion.m

@@ -0,0 +1,216 @@
+//
+//  IUTAssertion.m
+//  iUnitTest
+//
+//  Created by Katsuyoshi Ito on 09/01/16.
+//  Copyright 2009 ITO SOFT DESIGN Inc. All rights reserved.
+//
+
+#import "IUTAssertion.h"
+
+
+NSString * const IUTAssertionExceptionName = @"IUTAssertException";
+NSString * const IUTAssertionErrorExceptionName = @"IUTAssertErrorException";
+
+NSString * const IUTAssertionInfoKey = @"IUTAssertionInfoKey";
+
+
+@interface IUTAssertion(_private)
+- (NSException *)assertExceptionWithInfo:(IUTAssertionInfo *)info;
+@end
+ 
+
+@implementation IUTAssertion
+
+@synthesize assertedCount;
+
++ (NSException *)assertionErrorExceptionFrom:(NSException *)anException klass:(Class)klass selectorName:(NSString *)selectorString
+{
+    IUTAssertionInfo *info = [IUTAssertionInfo assertionInfoWithClass:klass selector:NSSelectorFromString(selectorString) message:anException.reason filePath:[NSString stringWithFormat:@"%@.m", NSStringFromClass(klass)] line:0];
+    
+    return [NSException exceptionWithName:IUTAssertionErrorExceptionName reason:nil userInfo:[NSDictionary dictionaryWithObjectsAndKeys:info, IUTAssertionInfoKey, nil]];
+}
+
+
+
+
+- (void)clearAssertedCount
+{
+    assertedCount = 0;
+}
+
+
+- (NSException *)assertExceptionWithInfo:(IUTAssertionInfo *)info
+{
+    return [NSException exceptionWithName:IUTAssertionExceptionName reason:nil userInfo:[NSDictionary dictionaryWithObjectsAndKeys:info, IUTAssertionInfoKey, nil]];
+}
+
+- (void)assert:(BOOL)value info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.expected = @"YES";
+    info.actual = value ? @"YES" : @"NO";
+    if (value == NO) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertSame:(id)value expected:(id)expected info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.actual = value;
+    info.expected = expected;
+    if (value != expected) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertNotSame:(id)value expected:(id)expected info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.actual = value;
+    info.expected = expected;
+    info.negativeCase = YES;
+    if (value == expected) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+
+
+- (void)assertEqual:(id)value expected:(id)expected info:(IUTAssertionInfo *)info
+{
+    if (expected == nil) {
+        [self assertNil:value info:info];
+    } else {
+        assertedCount++;
+        info.actual = value;
+        info.expected = expected;
+        if ([value isEqual:expected] == NO) {
+            @throw [self assertExceptionWithInfo:info];
+        }
+    }
+}
+
+- (void)assertNotEqual:(id)value expected:(id)expected info:(IUTAssertionInfo *)info
+{
+    if (expected == nil) {
+        [self assertNotNil:value info:info];
+    } else {
+        assertedCount++;
+        info.actual = value;
+        info.expected = expected;
+        info.negativeCase = YES;
+        if ([value isEqual:expected]) {
+            @throw [self assertExceptionWithInfo:info];
+        }
+    }
+}
+
+
+
+- (void)assertEqualInt:(int)value expected:(int)expected info:(IUTAssertionInfo *)info
+{
+    [self assertEqual:[NSNumber numberWithInt:value] expected:[NSNumber numberWithInt:expected] info:info];
+}
+
+- (void)assertNotEqualInt:(int)value expected:(int)expected info:(IUTAssertionInfo *)info
+{
+    [self assertNotEqual:[NSNumber numberWithInt:value] expected:[NSNumber numberWithInt:expected] info:info];
+}
+
+
+- (void)assertEqualFloat:(float)value expected:(float)expected info:(IUTAssertionInfo *)info
+{
+    [self assertEqual:[NSNumber numberWithFloat:value] expected:[NSNumber numberWithFloat:expected] info:info];
+}
+
+- (void)assertNotEqualFloat:(float)value expected:(float)expected info:(IUTAssertionInfo *)info
+{
+    [self assertNotEqual:[NSNumber numberWithFloat:value] expected:[NSNumber numberWithFloat:expected] info:info];
+}
+
+- (void)assertEqualFloat:(float)value expected:(float)expected delta:(float)delta info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.actual = [NSNumber numberWithFloat:value];
+    info.expected = [NSNumber numberWithFloat:expected];
+    info.delta = [NSNumber numberWithFloat:delta];
+    if (fabsf(expected - value) > delta) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertEqualDouble:(double)value expected:(double)expected info:(IUTAssertionInfo *)info
+{
+    [self assertEqual:[NSNumber numberWithDouble:value] expected:[NSNumber numberWithDouble:expected] info:info];
+}
+
+- (void)assertNotEqualDouble:(double)value expected:(double)expected info:(IUTAssertionInfo *)info
+{
+    [self assertNotEqual:[NSNumber numberWithDouble:value] expected:[NSNumber numberWithDouble:expected] info:info];
+}
+
+- (void)assertEqualDouble:(double)value expected:(double)expected delta:(double)delta info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.actual = [NSNumber numberWithDouble:value];
+    info.expected = [NSNumber numberWithDouble:expected];
+    info.delta = [NSNumber numberWithDouble:delta];
+    if (fabs(expected - value) > delta) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertNil:(id)value info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.expected = nil;
+    info.actual = value;
+    if (value != nil) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertNotNil:(id)value info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.expected = nil;
+    info.actual = value;
+    info.negativeCase = YES;
+    if (value == nil) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertEqualPoint:(CGPoint)value expected:(CGPoint)expected info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.expected = NSStringFromCGPoint(expected);
+    info.actual = NSStringFromCGPoint(value);
+    if (!CGPointEqualToPoint(value, expected)) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertEqualSize:(CGSize)value expected:(CGSize)expected info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.expected = NSStringFromCGSize(expected);
+    info.actual = NSStringFromCGSize(value);
+    if (!CGSizeEqualToSize(value, expected)) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+- (void)assertEqualRect:(CGRect)value expected:(CGRect)expected info:(IUTAssertionInfo *)info
+{
+    assertedCount++;
+    info.expected = NSStringFromCGRect(expected);
+    info.actual = NSStringFromCGRect(value);
+    if (!CGRectEqualToRect(value, expected)) {
+        @throw [self assertExceptionWithInfo:info];
+    }
+}
+
+@end

data/template/project/iUnitTest/iUnitTest/iunittest/UnitTest/IUTAssertionInfo.h

@@ -0,0 +1,60 @@
+//
+//  AssertionInfo.h
+//  iUnitTest
+//
+//  Created by Katsuyoshi Ito on 09/01/16.
+//  Copyright 2009 ITO SOFT DESIGN Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "SourceCodeOpener.h"
+
+
+#define IUTASSERTION_INF(m)  [IUTAssertionInfo assertionInfoWithClass:[self class] selector:_cmd message:m filePath:[[[NSString alloc] initWithCString:__FILE__ encoding:NSUTF8StringEncoding] autorelease] line:__LINE__]
+
+@interface IUTAssertionInfo : NSObject {
+
+    NSString *className;
+    NSString *methodName;
+    NSString *message;
+    NSString *filePath;
+    NSInteger line;
+
+    id expected;
+    id actual;
+    id delta;
+    
+    BOOL negativeCase;
+}
+
+@property (retain, readonly) NSString *className;
+@property (retain, readonly) NSString *methodName;
+@property (retain, readonly) NSString *message;
+@property (assign, readonly) NSString *reason;
+@property (retain, readonly) NSString *filePath;
+@property (assign, readonly) NSString *fileName;
+@property NSInteger line;
+
+@property (retain) id expected;
+@property (retain) id actual;
+@property (retain) id delta;
+
+@property BOOL negativeCase;
+
++ (id)assertionInfoWithClass:(Class)klass selector:(SEL)selector message:(NSString *)message filePath:(NSString *)path line:(NSInteger)line;
+
+- (id)initWithWithClass:(Class)klass selector:(SEL)selector message:(NSString *)message filePath:(NSString *)path line:(NSInteger)line;
+
+
+@end
+
+
+#if TARGET_IPHONE_SIMULATOR
+
+@interface SourceCodeOpener(IUTAssertionInfo)
+
+- (void)open:(IUTAssertionInfo *)info;
+
+@end
+
+#endif