Whitespace cleanup
authorWincent Colaiuta <win@wincent.com>
Mon, 23 Jul 2007 20:10:00 +0000 (22:10 +0200)
committerWincent Colaiuta <win@wincent.com>
Mon, 23 Jul 2007 20:10:00 +0000 (22:10 +0200)
Extensive whitespace cleanup of entire codebase (over 9,300 lines in the diff)
cleaning up mixed tabs and spaces (now uses spaces consistently) and trailing
whitespace at the end of lines.

Signed-off-by: Wincent Colaiuta <win@wincent.com>
56 files changed:
Doxyfile
INFO.txt
NOTES.txt
NSException+WOTest.h
NSException+WOTest.m
NSInvocation+WOTest.m
NSMethodSignature+WOTest.h
NSMethodSignature+WOTest.m
NSObject+WOTest.h
NSObject+WOTest.m
NSScanner+WOTest.h
NSScanner+WOTest.m
NSString+WOTest.h
NSString+WOTest.m
NSValue+WOTest.h
NSValue+WOTest.m
TODO.txt
Tests/NSObjectTests.m
Tests/NSScannerTests.m
Tests/NSValueTests.m
Tests/WOClassMockTests.m
Tests/WOMockTests.m
Tests/WOMultithreadedCrashTests.m
Tests/WOObjectMockTests.m
Tests/WOObjectStubTests.m
Tests/WOProtocolStubTests.m
Tests/WOStubTests.m
Tests/WOTestApplicationTestsControllerTests.h
Tests/WOTestSelfTests.m
WOClassMock.m
WOLightweightRoot.m
WOMock.h
WOMock.m
WOObjectMock.h
WOObjectMock.m
WOObjectStub.h
WOObjectStub.m
WOProtocolMock.h
WOProtocolMock.m
WOProtocolStub.h
WOProtocolStub.m
WOStub.h
WOStub.m
WOTestApplicationTestsController.h
WOTestApplicationTestsController.m
WOTestBundleInjector.m
WOTestClass.h
WOTestClass.m
WOTestLowLevelException.m
WOTestMacros.h
WOTestRunner/WOTestRunner.1
WOTestRunner/WOTestRunner.m
WOTestRunner/WOTestRunner_Version.h
WOTestSignalException.m
WOTest_Version.h
exc-notes.txt

index cb8a1425044002fd370ca56e5bc089787f0d3a32..61d7ae470223cb2ffcf5249977b6d29b1a58a39a 100644 (file)
--- a/Doxyfile
+++ b/Doxyfile
@@ -25,8 +25,8 @@ ABBREVIATE_BRIEF       = "The $name class" \
 ALWAYS_DETAILED_SEC    = NO
 INLINE_INHERITED_MEMB  = NO
 FULL_PATH_NAMES        = NO
-STRIP_FROM_PATH        = 
-STRIP_FROM_INC_PATH    = 
+STRIP_FROM_PATH        =
+STRIP_FROM_INC_PATH    =
 SHORT_NAMES            = NO
 JAVADOC_AUTOBRIEF      = YES
 MULTILINE_CPP_IS_BRIEF = NO
@@ -65,11 +65,11 @@ GENERATE_TODOLIST      = YES
 GENERATE_TESTLIST      = YES
 GENERATE_BUGLIST       = YES
 GENERATE_DEPRECATEDLIST= YES
-ENABLED_SECTIONS       = 
+ENABLED_SECTIONS       =
 MAX_INITIALIZER_LINES  = 30
 SHOW_USED_FILES        = YES
 SHOW_DIRECTORIES       = YES
-FILE_VERSION_FILTER    = 
+FILE_VERSION_FILTER    =
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
 #---------------------------------------------------------------------------
@@ -79,7 +79,7 @@ WARN_IF_UNDOCUMENTED   = YES
 WARN_IF_DOC_ERROR      = YES
 WARN_NO_PARAMDOC       = NO
 WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           = 
+WARN_LOGFILE           =
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
@@ -87,15 +87,15 @@ INPUT                  = .
 FILE_PATTERNS          = *.h \
                          *.H
 RECURSIVE              = YES
-EXCLUDE                = 
+EXCLUDE                =
 EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       = 
-EXAMPLE_PATH           = 
+EXCLUDE_PATTERNS       =
+EXAMPLE_PATH           =
 EXAMPLE_PATTERNS       = *
 EXAMPLE_RECURSIVE      = NO
-IMAGE_PATH             = 
-INPUT_FILTER           = 
-FILTER_PATTERNS        = 
+IMAGE_PATH             =
+INPUT_FILTER           =
+FILTER_PATTERNS        =
 FILTER_SOURCE_FILES    = NO
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
@@ -113,20 +113,20 @@ VERBATIM_HEADERS       = YES
 #---------------------------------------------------------------------------
 ALPHABETICAL_INDEX     = YES
 COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          = 
+IGNORE_PREFIX          =
 #---------------------------------------------------------------------------
 # configuration options related to the HTML output
 #---------------------------------------------------------------------------
 GENERATE_HTML          = YES
 HTML_OUTPUT            = html
 HTML_FILE_EXTENSION    = .html
-HTML_HEADER            = 
-HTML_FOOTER            = 
-HTML_STYLESHEET        = 
+HTML_HEADER            =
+HTML_FOOTER            =
+HTML_STYLESHEET        =
 HTML_ALIGN_MEMBERS     = YES
 GENERATE_HTMLHELP      = NO
-CHM_FILE               = 
-HHC_LOCATION           = 
+CHM_FILE               =
+HHC_LOCATION           =
 GENERATE_CHI           = NO
 BINARY_TOC             = NO
 TOC_EXPAND             = NO
@@ -143,8 +143,8 @@ LATEX_CMD_NAME         = latex
 MAKEINDEX_CMD_NAME     = makeindex
 COMPACT_LATEX          = NO
 PAPER_TYPE             = a4wide
-EXTRA_PACKAGES         = 
-LATEX_HEADER           = 
+EXTRA_PACKAGES         =
+LATEX_HEADER           =
 PDF_HYPERLINKS         = YES
 USE_PDFLATEX           = YES
 LATEX_BATCHMODE        = NO
@@ -156,8 +156,8 @@ GENERATE_RTF           = NO
 RTF_OUTPUT             = rtf
 COMPACT_RTF            = NO
 RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    = 
-RTF_EXTENSIONS_FILE    = 
+RTF_STYLESHEET_FILE    =
+RTF_EXTENSIONS_FILE    =
 #---------------------------------------------------------------------------
 # configuration options related to the man page output
 #---------------------------------------------------------------------------
@@ -170,8 +170,8 @@ MAN_LINKS              = NO
 #---------------------------------------------------------------------------
 GENERATE_XML           = NO
 XML_OUTPUT             = xml
-XML_SCHEMA             = 
-XML_DTD                = 
+XML_SCHEMA             =
+XML_DTD                =
 XML_PROGRAMLISTING     = YES
 #---------------------------------------------------------------------------
 # configuration options for the AutoGen Definitions output
@@ -183,29 +183,29 @@ GENERATE_AUTOGEN_DEF   = NO
 GENERATE_PERLMOD       = NO
 PERLMOD_LATEX          = NO
 PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX = 
+PERLMOD_MAKEVAR_PREFIX =
 #---------------------------------------------------------------------------
-# Configuration options related to the preprocessor   
+# Configuration options related to the preprocessor
 #---------------------------------------------------------------------------
 ENABLE_PREPROCESSING   = YES
 MACRO_EXPANSION        = NO
 EXPAND_ONLY_PREDEF     = NO
 SEARCH_INCLUDES        = YES
-INCLUDE_PATH           = 
-INCLUDE_FILE_PATTERNS  = 
-PREDEFINED             = 
-EXPAND_AS_DEFINED      = 
+INCLUDE_PATH           =
+INCLUDE_FILE_PATTERNS  =
+PREDEFINED             =
+EXPAND_AS_DEFINED      =
 SKIP_FUNCTION_MACROS   = YES
 #---------------------------------------------------------------------------
-# Configuration::additions related to external references   
+# Configuration::additions related to external references
 #---------------------------------------------------------------------------
-TAGFILES               = 
-GENERATE_TAGFILE       = 
+TAGFILES               =
+GENERATE_TAGFILE       =
 ALLEXTERNALS           = NO
 EXTERNAL_GROUPS        = YES
 PERL_PATH              = /usr/bin/perl
 #---------------------------------------------------------------------------
-# Configuration options related to the dot tool   
+# Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 CLASS_DIAGRAMS         = NO
 HIDE_UNDOC_RELATIONS   = YES
@@ -223,7 +223,7 @@ GRAPHICAL_HIERARCHY    = YES
 DIRECTORY_GRAPH        = YES
 DOT_IMAGE_FORMAT       = png
 DOT_PATH               = /usr/local/bin
-DOTFILE_DIRS           = 
+DOTFILE_DIRS           =
 MAX_DOT_GRAPH_WIDTH    = 1024
 MAX_DOT_GRAPH_HEIGHT   = 1024
 MAX_DOT_GRAPH_DEPTH    = 1000
@@ -232,6 +232,6 @@ DOT_MULTI_TARGETS      = NO
 GENERATE_LEGEND        = YES
 DOT_CLEANUP            = YES
 #---------------------------------------------------------------------------
-# Configuration::additions related to the search engine   
+# Configuration::additions related to the search engine
 #---------------------------------------------------------------------------
 SEARCHENGINE           = NO
index 70c6f2fc2a18ca06dc999430994844d7f1c3af75..b9fe58114d0c130bcc860234116a1bc36c59fbeb 100644 (file)
--- a/INFO.txt
+++ b/INFO.txt
@@ -1,4 +1,4 @@
-WOTest is an Objective-C unit testing framework written by Wincent Colaiuta 
+WOTest is an Objective-C unit testing framework written by Wincent Colaiuta
 <win@wincent.com>. More information available at:
 
 http://test.wincent.com/
index c472c6ce16ccf0f4665408f41ad5c5484bad3a39..10ddcf767bacef430e0dfcbe9c24ebe38776846b 100644 (file)
--- a/NOTES.txt
+++ b/NOTES.txt
@@ -72,7 +72,7 @@ Below is the set characteristics I wanted for WOTest which I couldn't find in an
 
 3. Xcode integration. It should be easy to automatically run the test suite from within Xcode, and not just by performing a "Run" (Command-R) but as a part of the actual build process (Command-B). You should be able to click on failed test results and be taken to the corresponding line in the source code.
 
-4. Separation of test target and non-test target. It should be possible to have a target in Xcode that doesn't run any tests, and a separate target that does run the tests. 
+4. Separation of test target and non-test target. It should be possible to have a target in Xcode that doesn't run any tests, and a separate target that does run the tests.
 
 5. No parallel hierarchies (either class hierarchies or category hierarchies). It shouldn't be necessary to maintain two hierarchies of code (one for the product and one for the tests) which could get out of synchronization (see the following two points).
 
@@ -84,7 +84,7 @@ Below is the set characteristics I wanted for WOTest which I couldn't find in an
 
 9. Ability to run unit tests from within the debugger.
 
-9. The code that ships should be tested, not the code that doesn't ship. I don't want to only test the "Development" build of the product and then ship an (untested!) "Deployment" build. Nor do I want to test a selection of classes from the product in isolation (for example, taking the source files for those selected classes and compiling them into my test suite). I want to test the exact code which will ship to customers. 
+9. The code that ships should be tested, not the code that doesn't ship. I don't want to only test the "Development" build of the product and then ship an (untested!) "Deployment" build. Nor do I want to test a selection of classes from the product in isolation (for example, taking the source files for those selected classes and compiling them into my test suite). I want to test the exact code which will ship to customers.
 
 10. Customers and beta-testers should be able to run the tests (if you want them to, that is). It's useful that third parties can run the tests for the purposes of support or squishing bugs. It is possible that the tests may pass "in house", but fail on other hardware or other configurations, and information gathered on those configurations is of obvious value.
 
@@ -124,18 +124,18 @@ But yes, the idea of unit testing did appeal to me. I looked at the existing uni
 There's a lot more to it than that, but this is what essentially lies at the heart of unit testing. So instead of grappling with any of those tools, I came up with a set of macros that enabled me to do unit testing. Here is a basic example:
 
     #ifdef DEBUG
-    
+
     /*! Test for a positive result (> 0) */
     #define WO_TEST_POSITIVE(expr)                                          \
     do {                                                                    \
         if ((expr) <= 0)                                                    \
             ELOG(@"Unit test failed (expected POSITIVE; obtained <= 0)");   \
     } while (0)
-    
+
     #else /* DEBUG not defined*/
-    
+
     #define WO_TEST_POSITIVE(expr)
-    
+
     #endif
 
 The ELOG macro was defined elsewhere, and logged the class, method, line number and so forth where the error was produced. Note that when the DEBUG flag is not defined (as is the case with "Deployment" builds), the tests produce no code. This means that the tests don't wind up in production code shipped to customers (which was in keeping with my goal at the time), but the down side is that the code that is tested is the "Development" build and not the "Deployment" build. It's conceivable (although it never happened to me) that tests could pass in the Development build yet the same function could fail in the "real world" deployment build.
@@ -157,7 +157,7 @@ WOTest can test itself
 
 Before I could use it to test itself, I had to complete a significant proportion of the code. "Test-Driven Development" was not an option, because until I had written the testing mechanism I didn't even know how I could write the tests. Now that WOTest is basically complete, it can be used to test itself. The key piece that needed to be written before I could start using WOTest to test itself was the WOTestRunner command-line executable.
 
-The tests appear in the file, "WOTestSelfTests.m". The file is a fairly comprehensive example of the kinds of tests that are possible with WOTest. Because the objective is to test the tests, all of the test methods include two approaches to the testing: one batch of tests that are expected to pass (in other words, if a test passes when it is expected to pass, then this is a pass); and a second batch of tests that are expected to fail (in other words, if a test fails a test when it is expected to fail, then this also is a pass). In this respect, this shows a highly atypical application of the tests; generally you would write code with the intention that all tests should pass, but in order to test that the tests work you must show that the both pass when you expect them to pass and fail when you expect them to fail. 
+The tests appear in the file, "WOTestSelfTests.m". The file is a fairly comprehensive example of the kinds of tests that are possible with WOTest. Because the objective is to test the tests, all of the test methods include two approaches to the testing: one batch of tests that are expected to pass (in other words, if a test passes when it is expected to pass, then this is a pass); and a second batch of tests that are expected to fail (in other words, if a test fails a test when it is expected to fail, then this also is a pass). In this respect, this shows a highly atypical application of the tests; generally you would write code with the intention that all tests should pass, but in order to test that the tests work you must show that the both pass when you expect them to pass and fail when you expect them to fail.
 
 However, the presence of all those failure warnings in the build log can make the test results hard to read. For this reason, WOTest implements a special variable (expectFailures) that should be used only during WOTest self-testing. When the flag is set, in addition to the standard "Failed" and "Passed" status messages, there are an additional two messages: "Failed (expected failure)" and "Passed (unexpected pass)". Normally in your own unit tests you wouldn't need to set the expectFailures variable; rather you would write tests such that an expected failure results in pass. This is much safer, because there's no risk of you setting the expectFailures variable to YES and later forgetting to set it back to NO.
 
@@ -184,7 +184,7 @@ To illustrate how this works, consider the following example. Imagine a tool tha
 By including the AppKit header file you ensure that the compiler doesn't give you any warnings, but if you try to build such code the linker will give you an error that "NSView" is an undefined symbol. Of course, even if you could produce an executable and run it, it wouldn't work because the executable isn't linked to the AppKit.framework. One way to force the framework to load is to set environment variables and then run the product from the command-line. For example, in the bash shell:
 
 export DYLD_FRAMEWORK_PATH=/System/Library/Frameworks
-export DYLD_INSERT_LIBRARIES=/System/Library/Frameworks/AppKit.framework/AppKit 
+export DYLD_INSERT_LIBRARIES=/System/Library/Frameworks/AppKit.framework/AppKit
 /path/to/executable
 
 On running, the executable has access to all of the AppKit.framework's classes, even though it didn't link to them. But this still doesn't solve the problem that the linker will complain about undefined symbols. One way around this is to pass "-undefined define_a_way" to the linker when building your executable (see the ld (1) man page for more options).
@@ -195,14 +195,14 @@ A far more elegant way to solve this problem is to take advantage of the dynamic
 
 - (void)callAppKitMethod
 {
-    NSBundle *theBundle = 
+    NSBundle *theBundle =
     [NSBundle bundleWithPath:@"/System/Library/Frameworks/AppKit.framework"];
     Class   viewClass   = [theBundle classNamed:@"NSView"];
     NSView  *aView      = [[viewClass alloc] initWithFrame:NSZeroRect];
     [aView release];
 }
 
-No compiler warnings, no linker errors, everything just works. WOTest uses this technique to allow you to load code "on the fly" without having to link to it. All it has to do is look for bundles, load them, and then run the test methods on them. 
+No compiler warnings, no linker errors, everything just works. WOTest uses this technique to allow you to load code "on the fly" without having to link to it. All it has to do is look for bundles, load them, and then run the test methods on them.
 
 ================================================================================
 How to test frameworks
@@ -310,7 +310,7 @@ Injecting a test bundle into a running application. Example taken from REnamer.a
 export WOTestInjectBundle="/Users/wincent/trabajo/build/Release/REnamer.app/Contents/Resources/ApplicationTests.bundle"
 export DYLD_INSERT_LIBRARIES="/Users/wincent/trabajo/build/Release/REnamer.app/Contents/Frameworks/WOTest.framework/WOTest"
 export DYLD_PRINT_LIBRARIES=1
-/Users/wincent/trabajo/build/Release/REnamer.app/Contents/MacOS/REnamer 
+/Users/wincent/trabajo/build/Release/REnamer.app/Contents/MacOS/REnamer
 
 ================================================================================
 Shipping testable production applications
index 40a382d9e784505a8444c8c47177824816fbd038..a361575b975207f63ae318e997c26ee4c227d017 100644 (file)
@@ -27,7 +27,7 @@
 #define WO_TEST_USERINFO_LINE   @"WOTestLine"
 #define WO_TEST_USERINFO_PATH   @"WOTestPath"
 
-@interface NSException (WOTest) 
+@interface NSException (WOTest)
 
 /*! Cocoa allows any Objective-C object to be thrown in an exception. Although NSException objects are most commonly used for this purpose there is no limitation that prevents other objects from being used. These objects may or may not respond to the name, reason and userInfo methods that are implemented by NSException. This method accepts any object and attempts to produce a textual description, using the name and reason methods if implemented and otherwise resorting to the description method if implented and finally a basic description based on the name of the class if not. */
 + (NSString *)WOTest_descriptionForException:(id)exception;
index 6525d729de7304825109b4fc2e577da971f06a57..2057738d85c6768a80e079aa6c7e9428f1bc1c30 100644 (file)
@@ -33,7 +33,7 @@
         else if ([NSObject WOTest_object:exception respondsToSelector:@selector(name)])
         {
             NSString *name = nil; // attempt to get name
-            
+
             if ([NSObject WOTest_objectReturnsId:exception forSelector:@selector(name)])
             {
                 name = [exception name];
@@ -46,7 +46,7 @@
                 const char *charString = (const char *)[exception name];
                 name = [NSString stringWithUTF8String:charString];
             }
-            
+
             NSString *reason = nil; // attempt to get reason
             if ([NSObject WOTest_object:exception respondsToSelector:@selector(reason)])
             {
@@ -63,7 +63,7 @@
                     reason = [NSString stringWithUTF8String:charString];
                 }
             }
-            
+
             if (name && reason)
                 return [NSString stringWithFormat:@"%@: %@", name, reason];
             else if (name)
         else
         {
             return [NSObject WOTest_descriptionForObject:exception];
-        }            
+        }
     }
     @catch (id e)
     {
         // fall through
     }
-    
+
     // last resort
     return [NSString stringWithFormat:@"unknown exception (%x)", exception];
 }
                 returnString = [NSString stringWithUTF8String:charString];
             }
         }
-        else 
+        else
             returnString = [NSObject WOTest_descriptionForObject:exception];
     }
     @catch (id e)
     {
         returnString = @"(exception caught trying to determine exception name)";
-    }    
+    }
     return returnString;
 }
 
index cf9a4fc35b27a93bb4f46467ea815d28da795ad5..c4a9dbe97b25dc28cfc42e52e4c4416a51a39b2b 100644 (file)
@@ -28,7 +28,7 @@
 {
     // first do a basic comparison without arguments
     if (![self WOTest_isEqualToInvocationIgnoringArguments:anInvocation]) return NO;
-    
+
     // compare arguments (skip first two: self and _cmd)
     NSMethodSignature *aSignature = [self methodSignature];
     NSMethodSignature *otherSignature = [anInvocation methodSignature];
         const char *aType = [aSignature getArgumentTypeAtIndex:i];
         const char *otherType = [otherSignature getArgumentTypeAtIndex:i];
         if (strcmp(aType, otherType) != 0) return NO;
-        
+
         // compare the two values
         return [[self WOTest_valueForArgumentAtIndex:i] isEqual:[anInvocation WOTest_valueForArgumentAtIndex:i]];
     }
-    
+
     return YES; // if get this far, all equality tests passed (no arguments)
 }
 
     // basic checks: compare against nil and against self
     if (!anInvocation) return NO;
     if (anInvocation == self) return YES;
-    
+
     // compare selectors
     if ([self selector] != [anInvocation selector]) return NO;
-    
+
     // compare signatures
     NSMethodSignature *aSignature = [self methodSignature];
     NSMethodSignature *otherSignature = [anInvocation methodSignature];
     if (![aSignature isEqual:otherSignature]) return NO;
-        
+
     return YES; // if get this far, all equality tests passed (no arguments)
 }
 
index 08e5a3d261ff729151c29f24481f8b0e051dca7d..780ed540dc9ef3af2eb5a61788ae62f76a536416 100644 (file)
@@ -21,7 +21,7 @@
 
 #import <Foundation/Foundation.h>
 
-@interface NSMethodSignature (WOTest) 
+@interface NSMethodSignature (WOTest)
 
 + (id)WOTest_signatureBasedOnObjCTypes:(const char *)types;
 
index a318fd937e3391779c84e2e115450e5e2bf2136d..b483115d809199d81dc303f08fc17dd2755f9625 100644 (file)
@@ -23,9 +23,9 @@
 #import <objc/objc-class.h>
 
 /*
+
  The real 10.4 NSMethodSignature API (obtained using class-dump; TODO: run class-dump to get 10.5 API):
+
 @interface NSMethodSignature : NSObject
 {
     char *_types;
@@ -58,13 +58,13 @@ The public API:
 
 @interface NSMethodSignature : NSObject {
     @private
-    const char *_types;
-    int                _nargs;
-    unsigned   _sizeofParams;
-    unsigned   _returnValueLength;
-    void       *_parmInfoP;
-    int                *_fixup;
-    void       *_reserved;
+    const char  *_types;
+    int         _nargs;
+    unsigned    _sizeofParams;
+    unsigned    _returnValueLength;
+    void        *_parmInfoP;
+    int         *_fixup;
+    void        *_reserved;
 }
 
 - (unsigned)numberOfArguments;
@@ -106,17 +106,17 @@ See also http://www.stuffonfire.com/2005/12/signaturewithobjctypes_is_stil.html
     NSParameterAssert(types != NULL);
 
 #ifdef WO_USE_OWN_METHOD_SIGNATURE_IMPLEMENTATION
-    
+
     return [[[self alloc] initWithObjCTypes:types] autorelease];
-    
+
 #else /* use private Apple API */
-    
+
     NSAssert([self respondsToSelector:@selector(signatureWithObjCTypes:)],
              @"signatureWithObjCTypes: selector not recognized");
     return [self signatureWithObjCTypes:types];
 
 #endif
-    
+
 }
 
 - (id)initWithObjCTypes:(const char *)types
@@ -128,9 +128,9 @@ See also http://www.stuffonfire.com/2005/12/signaturewithobjctypes_is_stil.html
         // loop through args
 /*        unsigned method_getNumberOfArguments(Method);
         unsigned method_getSizeOfArguments(Method); */
-        
+
         // I hate using private Apple APIs, even ones that appear stable, but
-        // not sure that meddling with these instance variables is a good idea        
+        // not sure that meddling with these instance variables is a good idea
     }
     return self;
 }
index 0c904336f2515e6cf10f7d6d79d72062c83959bf..3a0c06f8f387c882d4627f1f5eda76ba591e111d 100644 (file)
 
 #import <Foundation/Foundation.h>
 
-/*! WOTest is designed to work with any Objective-C class or object. You are not limited to working only with classes that derive from the Apple root classes (NSObject and NSProxy) or the other root classes (such as Object and NSZombie) that are implemented in libobjc (libobjc is part of Darwin and open source but the headers do not ship with Mac OS X). In most Objective-C programming you can assume that the objects with which you are working descend from NSObject and implement the NSObject protocol. This means that you can avoid exceptions by testing objects to see whether they implement selectors before sending messages; NSObject methods such as conformsToProtocol:, respondsToSelector: and performSelector: are frequently used for this purpose. 
+/*! WOTest is designed to work with any Objective-C class or object. You are not limited to working only with classes that derive from the Apple root classes (NSObject and NSProxy) or the other root classes (such as Object and NSZombie) that are implemented in libobjc (libobjc is part of Darwin and open source but the headers do not ship with Mac OS X). In most Objective-C programming you can assume that the objects with which you are working descend from NSObject and implement the NSObject protocol. This means that you can avoid exceptions by testing objects to see whether they implement selectors before sending messages; NSObject methods such as conformsToProtocol:, respondsToSelector: and performSelector: are frequently used for this purpose.
 
 If you try sending these messages to objects which do not implement them then you could cause a non-catchable exception (generated in _objc_error and _objc_trap) which will terminate the testing process. One of the goals of WOTest is to be extremely robust; exceptions should be caught and reported and they should not crash the program. It is true that custom root classes are extremely uncommon but WOTest nevertheless has been designed to cope with them. WOTest interacts with the Objective-C runtime at a low level and implements a number of convenience wrapper routines that enable the framework to work with any Objective-C object without fear of provoking uncatchable exceptions. The wrapper methods are described in this section. In simple cases (for example when invoking the objc_msgSend function) the framework calls the function directly without a wrapper. */
 
-@interface NSObject (WOTest) 
+@interface NSObject (WOTest)
 
 /*! Substitute for NSObject description method. Returns "(nil)" if \p anObject is nil. */
 + (NSString *)WOTest_descriptionForObject:(id)anObject;
index a35864ee89294155510c6972ff7acff01d981749..d69ca97fc84c42c89f9888d895d454245b833da8 100644 (file)
 + (NSString *)WOTest_descriptionForObject:(id)anObject
 {
     if (!anObject) return @"(nil)";
-    
+
     @try
     {
         // special case handling for NSValue objects
         if ([self WOTest_object:anObject isKindOfClass:[NSValue class]])
             return [(NSValue *)anObject WOTest_description];
-        
+
         // fallback case: try "description" selector
         if ([self WOTest_object:anObject respondsToSelector:@selector(description)])
         {
             NSString *returnType = [self WOTest_returnTypeForObject:anObject selector:@selector(description)];
-            
+
             if ([self WOTest_isIdReturnType:returnType])
             {
                 NSString *description = [anObject description];
                 if ([self WOTest_object:description isKindOfClass:[NSString class]])
                     return description;
             }
-            else if ([self WOTest_isCharacterStringReturnType:returnType] || 
+            else if ([self WOTest_isCharacterStringReturnType:returnType] ||
                      [self WOTest_isConstantCharacterStringReturnType:returnType])
             {
                 const char *charString = (const char *)[anObject description];
@@ -61,7 +61,7 @@
             }
         }
     }
-    @catch (id e) 
+    @catch (id e)
     {
         // fall through
     }
 + (BOOL)WOTest_isRegisteredClass:(Class)aClass
 {
     if (!aClass) return NO;
-    
+
     BOOL    isRegisteredClass   = NO;
     int     numClasses          = 0;
     int     newNumClasses       = objc_getClassList(NULL, 0);
     Class   *classes            = NULL;
-    
+
     // get list of all classes on the system
     while (numClasses < newNumClasses)
     {
         NSAssert1((classes != NULL), @"realloc() failed (size %d)", bufferSize);
         newNumClasses       = objc_getClassList(classes, numClasses);
     }
-    
+
     if (classes)
     {
         for (int i = 0; i < newNumClasses; i++)
-        { 
+        {
             if (aClass == classes[i])   // found in list!
             {
                 isRegisteredClass = YES;
 + (BOOL)WOTest_isMetaClass:(Class)aClass
 {
     if (!aClass) return NO;
-    
+
     BOOL    isMetaClass     = NO;
     int     numClasses      = 0;
     int     newNumClasses   = objc_getClassList(NULL, 0);
     Class   *classes        = NULL;
-    
+
     // get a list of all classes on the system
     // get list of all classes on the system
     while (numClasses < newNumClasses)
         NSAssert1((classes != NULL), @"realloc() failed (size %d)", bufferSize);
         newNumClasses       = objc_getClassList(classes, numClasses);
     }
-    
+
     if (classes)
     {
         for (int i = 0; i < newNumClasses; i++)
         {
             if (class_isMetaClass(classes[i]))  // looking at a meta class
             {
-                if (aClass == classes[i])              // found in list!
+                if (aClass == classes[i])       // found in list!
                 {
                     isMetaClass = YES;
                     break;
         }
         free(classes);
     }
-    return isMetaClass;    
+    return isMetaClass;
 }
 
 + (BOOL)WOTest_object:(id)anObject isKindOfClass:(Class)aClass
     NSParameterAssert([self WOTest_isRegisteredClass:aClass] || [self WOTest_isMetaClass:aClass]);
     if (!anObject)  return NO;
     Class objectClass = object_getClass(anObject);
-    
+
     if (objectClass == aClass)
         return YES;
     else
     {
-               // check superclass
+        // check superclass
         Class superClass = class_getSuperclass(objectClass);
-               if (superClass)
-                       return [self WOTest_instancesOfClass:superClass areKindOfClass:aClass];                
+        if (superClass)
+            return [self WOTest_instancesOfClass:superClass areKindOfClass:aClass];
     }
-    
+
     return NO; // give up
 }
 
     NSParameterAssert([self WOTest_isRegisteredClass:aClass] || [self WOTest_isMetaClass:aClass]);
     if (!otherClass)    return NO;
     NSParameterAssert([self WOTest_isRegisteredClass:otherClass] || [self WOTest_isMetaClass:otherClass]);
-    
+
     if (aClass == otherClass)
         return YES;
-       
-       Class superClass = class_getSuperclass(aClass);
+
+    Class superClass = class_getSuperclass(aClass);
     if (superClass)
         return [self WOTest_instancesOfClass:superClass areKindOfClass:otherClass];
-    
+
     return NO; // give up
 }
 
     if (!aClass)    return NO;
     NSParameterAssert([self WOTest_isRegisteredClass:aClass] || [self WOTest_isMetaClass:aClass]);
     if (!aProtocol) return NO;
-       if (class_conformsToProtocol(aClass, aProtocol))
-               return YES;
-       Class superClass = class_getSuperclass(aClass);
-       if (superClass)
+    if (class_conformsToProtocol(aClass, aProtocol))
+        return YES;
+    Class superClass = class_getSuperclass(aClass);
+    if (superClass)
         return [self WOTest_instancesOfClass:superClass conformToProtocol:aProtocol];
-    
+
     return NO;  // give up
 }
 
     NSParameterAssert([self WOTest_isRegisteredClass:aClass] || [self WOTest_isMetaClass:aClass]);
     NSParameterAssert(aSelector != NULL);
     Method theMethod = class_getClassMethod(aClass, aSelector);
-    
+
     if (theMethod == NULL) // class does not respond to this selector
         return nil;
 
     // get return type and list of arguments
-       char *returnType = method_copyReturnType(theMethod);
-       if (returnType)
-       {
-               NSString *returnString = [[NSString alloc] initWithUTF8String:returnType];
-               free(returnType);
-               return returnString;
-       }
-       return nil;
+    char *returnType = method_copyReturnType(theMethod);
+    if (returnType)
+    {
+        NSString *returnString = [[NSString alloc] initWithUTF8String:returnType];
+        free(returnType);
+        return returnString;
+    }
+    return nil;
 }
 
 + (NSString *)WOTest_returnTypeForObject:(id)anObject selector:(SEL)aSelector
     NSParameterAssert(anObject != nil);
     NSParameterAssert(aSelector != NULL);
     Method theMethod = class_getInstanceMethod(object_getClass(anObject), aSelector);
-               
-       if (theMethod == NULL) // object does not respond to this selector
+
+    if (theMethod == NULL) // object does not respond to this selector
         return nil;
-       
+
     // get return type and list of arguments
-       char *returnType = method_copyReturnType(theMethod);
-       if (returnType)
-       {
-               NSString *typeString = [NSString stringWithUTF8String:returnType];
-               free(returnType);
-               return typeString;
-       }
-       return nil;    
+    char *returnType = method_copyReturnType(theMethod);
+    if (returnType)
+    {
+        NSString *typeString = [NSString stringWithUTF8String:returnType];
+        free(returnType);
+        return typeString;
+    }
+    return nil;
 }
 
 + (BOOL)WOTest_isIdReturnType:(NSString *)returnType
 {
     NSParameterAssert(anObject != nil);
     NSParameterAssert(aSelector != NULL);
-    return [self WOTest_isConstantCharacterStringReturnType:[self WOTest_returnTypeForObject:anObject selector:aSelector]];    
+    return [self WOTest_isConstantCharacterStringReturnType:[self WOTest_returnTypeForObject:anObject selector:aSelector]];
 }
 
 @end
index 9a7f16b236dc2193acf85ec3e9965be7131e1bc9..4b8f67ab5001a64fcd7c0b578c688e24088c0391 100644 (file)
 
 #import <Foundation/Foundation.h>
 
-/*! 
+/*!
  Example method signatures and types:
+
  The documentation notes the following: "The compiler generates the method type encodings in a format that includes information on the size of the stack and the size occupied by the arguments. These numbers appear after each encoding in the method_types string. However, because the compiler historically generates them incorrectly, and because they differ depending on the CPU type, the runtime ignores them if they are present. These numbers are not required by the Objective-C runtime in Mac OS X v10.0 or later."
+
  The first entry indicates the type of the return value.
  This is followed by the first argument which is always \@0 or \@8 (self).
  The second argument is always :4 or :12 (_cmd).
  Any subsequent arguments follow.
+
  + new  : \@8\@0:4
+
  + (const char *) name  : r*8\@0:4
  - (const char *) name : r*8\@0:4
  - (void *)zone :  ^v8\@0:4
  - (BOOL) conformsTo: (Protocol *)aProtocolObject : c12\@0:4\@8
+
  + (id)allocWithZone:(NSZone *)zone : \@12\@0:4^{_NSZone=}8
+
  + (Class)class : #8\@0:4
- + (void)cancelPreviousPerformRequestsWithTarget:(id)aTarget 
+
+ + (void)cancelPreviousPerformRequestsWithTarget:(id)aTarget
  selector:(SEL)aSelector object:(id)anArgument
  v20\@0:4\@8:12\@16
+
  + (NSRect)contentRectForFrameRect:(NSRect)frameRect styleMask:(unsigned int)aStyle
- {_NSRect={_NSPoint=ff}{_NSSize=ff}}28\@0:4{_NSRect={_NSPoint=ff}{_NSSize=ff}}8I24    
+ {_NSRect={_NSPoint=ff}{_NSSize=ff}}28\@0:4{_NSRect={_NSPoint=ff}{_NSSize=ff}}8I24
+
  + (id)stringWithString:(NSString *)aString : \@12\@0:4\@8
+
  + (NSString *)localizedNameOfStringEncoding:(NSStringEncoding)encoding
  \@12\@0:4\@8
- See objc/objc-class.h for macros 
+
+ See objc/objc-class.h for macros
+
+
 Additional codes used by runtime as described here: file:///Developer/ADC%20Reference%20Library/documentation/Cocoa/Conceptual/ObjectiveC/RuntimeOverview/chapter_4_section_6.html */
 
 #define WO_ENCODING_QUALIFIER_CONST     'r'
@@ -67,7 +67,7 @@ Additional codes used by runtime as described here: file:///Developer/ADC%20Refe
 #define WO_ENCODING_QUALIFIER_BYREF     'R'
 #define WO_ENCODING_QUALIFIER_ONEWAY    'V'
 
-@interface NSScanner (WOTest) 
+@interface NSScanner (WOTest)
 
 /*! Raises an NSInternalInconsistencyException if value is NULL. */
 - (BOOL)WOTest_peekCharacter:(unichar *)value;
index a31ae1d0f9307e7fe91e42626bb06f8be34c6b10..a99b89fe8dad010619f4e2a72ce262a7eb604c98 100644 (file)
     {
         *value = [string characterAtIndex:scanLocation];
         return YES;
-    }   
+    }
     return NO;
 }
 
 - (BOOL)WOTest_scanCharacter:(unichar *)value;
-{    
+{
     unichar  character;
     if ([self WOTest_peekCharacter:&character])
     {
@@ -57,7 +57,7 @@
 - (BOOL)WOTest_scanCharacterFromSet:(NSCharacterSet *)scanSet intoChar:(unichar *)value;
 {
     if (!scanSet) return NO; // nothing to do
-    
+
     unsigned    scanLocation = [self scanLocation];
     unichar     character;
     if ([self WOTest_scanCharacter:&character] && [scanSet characterIsMember:character])
@@ -66,7 +66,7 @@
             *value = character;
         return YES;
     }
-    
+
     [self setScanLocation:scanLocation]; // revert
     return NO;
 }
@@ -75,7 +75,7 @@
 {
     if ([self scanLocation] != 0)
         return NO; // the return type must be at the start of the string
-    
+
     // scan a single type (the first one will be the return type)
     return [self WOTest_scanTypeIntoString:stringValue];
 }
     unsigned    scanLocation        = [self scanLocation];
     NSString    *qualifiers         = nil;
     NSString    *type               = nil;
-    
+
     // scan any qualifers that are present
     if (![self WOTest_scanQualifiersIntoString:&qualifiers]) qualifiers = @"";
-    
+
     // scan type
     if ([self WOTest_scanBitfieldIntoString:&type]          ||
         [self scanPointerIntoString:&type]                  ||
     {
         // success
         if (stringValue)
-            *stringValue = 
+            *stringValue =
                 [NSString stringWithFormat:@"%@%@", qualifiers, type];
-        return YES;        
+        return YES;
     }
-    
+
     [self setScanLocation:scanLocation]; // revert
     return NO;
 }
 
 - (BOOL)WOTest_scanQualifiersIntoString:(NSString **)stringValue
-{    
-    NSCharacterSet *qualifiersSet = 
+{
+    NSCharacterSet *qualifiersSet =
     [NSCharacterSet characterSetWithCharactersInString:
         [NSString stringWithFormat:@"%C%C%C%C%C%C%C",
             WO_ENCODING_QUALIFIER_CONST,    WO_ENCODING_QUALIFIER_IN,
             WO_ENCODING_QUALIFIER_INOUT,    WO_ENCODING_QUALIFIER_OUT,
             WO_ENCODING_QUALIFIER_BYCOPY,   WO_ENCODING_QUALIFIER_BYREF,
             WO_ENCODING_QUALIFIER_ONEWAY]];
-    
+
     return [self scanCharactersFromSet:qualifiersSet
                             intoString:stringValue];
 }
 
 - (BOOL)WOTest_scanNonCompoundTypeIntoString:(NSString **)stringValue
 {
-    NSCharacterSet *nonCompoundSet = 
+    NSCharacterSet *nonCompoundSet =
     [NSCharacterSet characterSetWithCharactersInString:
         [NSString stringWithFormat:@"%C%C%C%C%C%C%C%C%C%C%C%C%C%C%C%C%C%C%C",
-            _C_ID,      _C_CLASS,   _C_SEL,     _C_CHR,     _C_UCHR,    
+            _C_ID,      _C_CLASS,   _C_SEL,     _C_CHR,     _C_UCHR,
             _C_SHT,     _C_USHT,    _C_INT,     _C_UINT,    _C_LNG,
-            _C_ULNG,    _C_LNGLNG,  _C_ULNGLNG, _C_FLT,     _C_DBL,     
+            _C_ULNG,    _C_LNGLNG,  _C_ULNGLNG, _C_FLT,     _C_DBL,
             _C_99BOOL,  _C_VOID,    _C_UNDEF,   _C_CHARPTR]];
-    
+
     unichar character;
     if ([self WOTest_scanCharacterFromSet:nonCompoundSet intoChar:&character])
     {
         if (stringValue)
-            *stringValue = [NSString WOTest_stringWithCharacter:character]; 
+            *stringValue = [NSString WOTest_stringWithCharacter:character];
         return YES;
     }
-     
+
     return NO;
 }
 
 - (BOOL)WOTest_scanBitfieldIntoString:(NSString **)stringValue
 {
     unsigned scanLocation = [self scanLocation];
-    
+
     unichar marker; // look for bitfield marker
     int num;        // scan number of bits
     if ([self WOTest_scanCharacter:&marker] && (marker == _C_BFLD) && [self scanInt:&num])
             *stringValue = [NSString stringWithFormat:@"%C%d", marker, num];
         return YES;
     }
-    
+
     [self setScanLocation:scanLocation]; // revert
     return NO;
 }
 - (BOOL)WOTest_scanArrayIntoString:(NSString **)stringValue
 {
     unsigned scanLocation = [self scanLocation];
-    
+
     unichar startMarker, endMarker; // look for array start marker
     int num;                        // scan number of elements
     NSString *type;                 // scan type of elements
-    
+
     if ([self WOTest_scanCharacter:&startMarker] && (startMarker == _C_ARY_B) &&
         [self scanInt:&num] && [self WOTest_scanTypeIntoString:&type] &&
         [self WOTest_scanCharacter:&endMarker] && (endMarker == _C_ARY_E))
             *stringValue = [NSString stringWithFormat:@"%C%d%@%C", startMarker, num, type, endMarker];
         return YES;
     }
-    
-    
+
+
     [self setScanLocation:scanLocation]; // revert
     return NO;
 }
 - (BOOL)WOTest_scanIdentifierIntoString:(NSString **)stringValue
 {
     unsigned scanLocation = [self scanLocation];
-    
+
     unichar firstChar, equalsChar;
     if ([self WOTest_peekCharacter:&firstChar])
     {
         // identifiers must begin with a letter or underscore (no numbers!)
-        if (((firstChar >= 'a') && (firstChar <= 'z')) || 
+        if (((firstChar >= 'a') && (firstChar <= 'z')) ||
             ((firstChar >= 'A') && (firstChar <= 'Z')) ||
             (firstChar == '_'))
         {
             }
         }
     }
-    
+
     [self setScanLocation:scanLocation]; // revert
     return NO;
 }
 - (BOOL)WOTest_scanStructIntoString:(NSString **)stringValue
 {
     unsigned scanLocation = [self scanLocation];
-    
+
     unichar startMarker, endMarker;
     NSString *identifier;
     if ([self WOTest_scanCharacter:&startMarker] && (startMarker == _C_STRUCT_B))
         if ([self WOTest_scanIdentifierIntoString:&identifier])
         {
             [self WOTest_scanCharacter:NULL]; // scan past "="
-            
+
             // prepare identifier for later insertion (append equals sign)
             identifier = [NSString stringWithFormat:@"%@=", identifier];
         }
         else // optional identifier not found
             identifier = @"";
-        
+
         // scan types until you hit end marker
         NSMutableString *types = [NSMutableString string];
         NSString *type;
             [types appendString:type];
             [self scanInt:nil]; // skip over any superfluous numbers in string
         }
-        
+
         // scan end marker
         if ([self WOTest_scanCharacter:&endMarker] && (endMarker == _C_STRUCT_E))
         {
 - (BOOL)WOTest_scanUnionIntoString:(NSString **)stringValue
 {
     unsigned scanLocation = [self scanLocation];
-    
+
     unichar startMarker, equalsMarker, endMarker;
     NSString *identifier;
     if ([self WOTest_scanCharacter:&startMarker] && (startMarker == _C_UNION_B))
             [types appendString:type];
             [self scanInt:nil]; // skip over any superfluous numbers in string
         }
-        
+
         // scan end marker
         if ([self WOTest_scanCharacter:&endMarker] && (endMarker == _C_UNION_E))
         {
             return YES;
         }
     }
-        
+
     [self setScanLocation:scanLocation]; // revert
-    return NO;    
+    return NO;
 }
 
 - (BOOL)scanPointerIntoString:(NSString **)stringValue
 {
     unsigned scanLocation = [self scanLocation];
-    
+
     unichar marker; // look for pointer marker
     NSString *type; // scan type to which pointer points
     if ([self WOTest_scanCharacter:&marker] && (marker == _C_PTR) && [self WOTest_scanTypeIntoString:&type])
             *stringValue = [NSString stringWithFormat:@"%C%@", marker, type];
         return YES;
     }
-    
+
     [self setScanLocation:scanLocation]; // revert
     return NO;
 }
index 5fde99700c154dcabe9df313c53e1280a3538f9d..2a0901ff0d2d774a4f0dfe85d4c17e660d763299 100644 (file)
@@ -27,7 +27,7 @@ void _WOLog(NSString *format, ...);
 /*! This function is an alternative to NSLogv that accepts the same kinds of format specifiers (including the "%@" format specifier to print object descriptions) but which omits the prelimary information that is prepended by NSLogv (date, time, process name, process number). Named with a preceding underscore for consistency with the _WOLog function. */
 void _WOLogv(NSString *format, va_list args);
 
-@interface NSString (WOTest) 
+@interface NSString (WOTest)
 
 + (NSString *)WOTest_stringWithFormat:(NSString *)format arguments:(va_list)argList;
 
index aa7f8e1f49973bd3056eca697d560a45693f9f35..aa63f02a16354278523d922fc8d754792167b7f4 100644 (file)
@@ -44,7 +44,7 @@ void _WOLogv(NSString *format, va_list args)
     {
         fprintf(stdout, "%s\n", [string UTF8String]);
         fflush(NULL); // flush all open streams (not just stdout)
-        [string release]; 
+        [string release];
     }
 }
 
@@ -52,7 +52,7 @@ void _WOLogv(NSString *format, va_list args)
 
 + (NSString *)WOTest_stringWithFormat:(NSString *)format arguments:(va_list)argList
 {
-    return [[[NSString alloc] initWithFormat:format 
+    return [[[NSString alloc] initWithFormat:format
                                    arguments:argList] autorelease];
 }
 
@@ -66,7 +66,7 @@ void _WOLogv(NSString *format, va_list args)
     if ([self isAbsolutePath])
         return self;
     NSString *path = [[NSFileManager defaultManager] currentDirectoryPath];
+
     // TODO: strictly speaking, should write a method stringByAppendPathComponents (see draft above)
     return [path stringByAppendingPathComponent:self];
 }
@@ -82,7 +82,7 @@ void _WOLogv(NSString *format, va_list args)
         {
             // convert newslines, tabs etc to spaces
             [temp replaceCharactersInRange:NSMakeRange(i, 1) withString:@" "];
-            
+
             // was the last character also a space?
             if ((i > 0) && ([temp characterAtIndex:i - 1] == ' '))
             {
index b636fccf498cffbd1ba41e61741f6b3cc90cf24e..0972193defa68c827f7afb6b67bd0589432d9ecf 100644 (file)
@@ -26,7 +26,7 @@
 #ifndef _C_LNGLNG
 
 /*! Type macros missing from objc-class.h at the time of writing; definition taken from docs file:///Developer/ADC%20Reference%20Library/documentation/Cocoa/Conceptual/ObjectiveC/index.html */
-#define _C_LNGLNG 'q' 
+#define _C_LNGLNG 'q'
 
 #endif
 
@@ -59,7 +59,7 @@ Any object can be compared to any other object for equality provided that it imp
 Objects can be compared to one another for ordering provided that they are of the same class (or at least have a super-subclass relationship) and at least one of the objects implement the compare: method. If neither of these conditions are true then an NSInvalidArgument exception will be raised.
 
 Class objects, method selectors (SEL), void types, character strings (char *), arrays, structs, unions and pointers have no special behaviour implemented in this category. If you try to compare them the standard isEqualTo: NSValue method will be used and testing the ordering will raise an NSInvalidArgument exception. */
-@interface NSValue (WOTest) 
+@interface NSValue (WOTest)
 
 #pragma mark -
 #pragma mark Value creation methods
@@ -139,25 +139,25 @@ Class objects, method selectors (SEL), void types, character strings (char *), a
 
 + (BOOL)WOTest_typeIsInt:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsShort:(NSString *)typeString;  
++ (BOOL)WOTest_typeIsShort:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsLong:(NSString *)typeString;      
++ (BOOL)WOTest_typeIsLong:(NSString *)typeString;
 
 + (BOOL)WOTest_typeIsLongLong:(NSString *)typeString;
 
 + (BOOL)WOTest_typeIsUnsignedChar:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsUnsignedInt:(NSString *)typeString;    
++ (BOOL)WOTest_typeIsUnsignedInt:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsUnsignedShort:(NSString *)typeString;  
++ (BOOL)WOTest_typeIsUnsignedShort:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsUnsignedLong:(NSString *)typeString;   
++ (BOOL)WOTest_typeIsUnsignedLong:(NSString *)typeString;
 
 + (BOOL)WOTest_typeIsUnsignedLongLong:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsFloat:(NSString *)typeString;          
++ (BOOL)WOTest_typeIsFloat:(NSString *)typeString;
 
-+ (BOOL)WOTest_typeIsDouble:(NSString *)typeString;  
++ (BOOL)WOTest_typeIsDouble:(NSString *)typeString;
 
 + (BOOL)WOTest_typeIsC99Bool:(NSString *)typeString;
 
@@ -176,7 +176,7 @@ Class objects, method selectors (SEL), void types, character strings (char *), a
 + (BOOL)WOTest_typeIsPointerToVoid:(NSString *)typeString;
 
 + (BOOL)WOTest_typeIsPointer:(NSString *)typeString;
-    
+
 + (BOOL)WOTest_typeIsArray:(NSString *)typeString;
 
 + (BOOL)WOTest_typeIsStruct:(NSString *)typeString;
@@ -189,7 +189,7 @@ Class objects, method selectors (SEL), void types, character strings (char *), a
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark High-level test methods
 
 /*!
@@ -221,7 +221,7 @@ Special case handling notwithstanding, attempting to compare a non-zero int with
 WO_TEST_EQUAL(25, aString);             // raises
 \endcode
 
-In all other cases the default NSValue isEqualToValue: method is used as a fallback. 
+In all other cases the default NSValue isEqualToValue: method is used as a fallback.
 
 <table>
 <tr>
@@ -527,7 +527,7 @@ Table corresponds to the warnings produced by the version of GCC 4.0 that ships
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Utility methods
 
 //! \name Utility methods
@@ -727,7 +727,7 @@ When encoded as NSValues the two constant strings in the example above would be
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Low-level test methods
 
 /*!
index a48d8fc8253541cb89efd04866c97f3f0039fee9..da1dfb41d0e78d0cc4ebc671db371726b335121f 100644 (file)
@@ -83,7 +83,7 @@
 
 + (NSValue *)WOTest_valueWithUnsignedLongLong:(unsigned long long)anUnsignedLongLong
 {
-    return [NSValue value:&anUnsignedLongLong withObjCType:@encode(unsigned long long)]; 
+    return [NSValue value:&anUnsignedLongLong withObjCType:@encode(unsigned long long)];
 }
 
 + (NSValue *)WOTest_valueWithFloat:(float)aFloat
 
 + (NSValue *)WOTest_valueWithConstantCharacterString:(const char *)aConstantCharString
 {
-    return [NSValue value:&aConstantCharString withObjCType:@encode(const char *)]; 
+    return [NSValue value:&aConstantCharString withObjCType:@encode(const char *)];
 }
 
 + (NSValue *)WOTest_valueWithCharacterString:(char *)aCharacterString
 
     if ([self WOTest_typeIsBitfield:typeString])
         return sizeof(int);
-    
+
 #if defined (__i386__)
 
     if ([self WOTest_typeIsC99Bool:typeString]                         ||
         // long double        16 bytes
         // vector (64 bits)   8 bytes
         // vector (128 bits)  16 bytes
-        [NSException raise:NSInternalInconsistencyException 
+        [NSException raise:NSInternalInconsistencyException
                     format:@"Type %@ not supported by WOTest_maximumEmbeddedSizeForType:", typeString];
-                        
+
 #elif defined (__ppc__)
-    
+
     if ([self WOTest_typeIsUnsignedChar:typeString]                    ||
         [self WOTest_typeIsChar:typeString])
         size = 1;   // scalars of size/alignment 1
         // long double  8 bytes (Mac OS X < 10.4, GCC < 4.0)
         // long double  16 bytes (Mac OS X >= 10.4, GCC >= 4.0)
         // vector       16 bytes
-        [NSException raise:NSInternalInconsistencyException 
+        [NSException raise:NSInternalInconsistencyException
                     format:@"Type %@ not supported by WOTest_maximumEmbeddedSizeForType:", typeString];
 
 #elif defined (__ppc64__)
         // documented in "Mac OS X ABI Function Call Guide" but not supported:
         // long double  16 bytes
         // vector       16 bytes
-        [NSException raise:NSInternalInconsistencyException 
+        [NSException raise:NSInternalInconsistencyException
                     format:@"Type %@ not supported by WOTest_maximumEmbeddedSizeForType:", typeString];
-                        
+
 #else
-                        
+
 #error Unsupported architecture
 
 #endif
-                            
+
     return size;
 }
 
 {
     NSParameterAssert(typeString != nil);
     size_t size = 0;
-    
+
     if ([self WOTest_typeIsChar:typeString])
         size = sizeof(char);
     else if ([self WOTest_typeIsInt:typeString])
         size = sizeof(int);
-    else if ([self WOTest_typeIsShort:typeString])  
+    else if ([self WOTest_typeIsShort:typeString])
         size = sizeof(short);
-    else if ([self WOTest_typeIsLong:typeString])      
+    else if ([self WOTest_typeIsLong:typeString])
         size = sizeof(long);
     else if ([self WOTest_typeIsLongLong:typeString])
         size = sizeof(long long);
     else if ([self WOTest_typeIsUnsignedChar:typeString])
         size = sizeof(unsigned char);
-    else if ([self WOTest_typeIsUnsignedInt:typeString])    
+    else if ([self WOTest_typeIsUnsignedInt:typeString])
         size = sizeof(unsigned int);
-    else if ([self WOTest_typeIsUnsignedShort:typeString])  
+    else if ([self WOTest_typeIsUnsignedShort:typeString])
         size = sizeof(unsigned short);
-    else if ([self WOTest_typeIsUnsignedLong:typeString])   
+    else if ([self WOTest_typeIsUnsignedLong:typeString])
         size = sizeof(unsigned long);
     else if ([self WOTest_typeIsUnsignedLongLong:typeString])
         size = sizeof(unsigned long long);
-    else if ([self WOTest_typeIsFloat:typeString])          
+    else if ([self WOTest_typeIsFloat:typeString])
         size = sizeof(float);
-    else if ([self WOTest_typeIsDouble:typeString])  
+    else if ([self WOTest_typeIsDouble:typeString])
         size = sizeof(double);
     else if ([self WOTest_typeIsC99Bool:typeString])
         size = sizeof(_Bool);
             unichar startMarker, endMarker;
             int count;
             NSString *elementType;
-            if ([scanner WOTest_scanCharacter:&startMarker] && 
-                (startMarker == _C_ARY_B) && [scanner scanInt:&count] && 
+            if ([scanner WOTest_scanCharacter:&startMarker] &&
+                (startMarker == _C_ARY_B) && [scanner scanInt:&count] &&
                 [scanner WOTest_scanTypeIntoString:&elementType] &&
                 [scanner WOTest_scanCharacter:&endMarker] && (endMarker == _C_ARY_E) &&
                 [scanner isAtEnd])
                 size = [self WOTest_sizeForType:elementType] * count;
             }
             else
-                [NSException raise:NSInternalInconsistencyException 
+                [NSException raise:NSInternalInconsistencyException
                             format:@"scanner error in sizeForType for type %@", typeString];
         }
         else if ([self WOTest_typeIsStruct:typeString])
         {
             NSScanner *scanner = [NSScanner scannerWithString:typeString];
             unichar startMarker, endMarker;
-            
-            if ([scanner WOTest_scanCharacter:&startMarker] && 
+
+            if ([scanner WOTest_scanCharacter:&startMarker] &&
                 (startMarker == _C_STRUCT_B))
             {
                 // scan optional identifier
-                if ([scanner WOTest_scanIdentifierIntoString:nil]) 
+                if ([scanner WOTest_scanIdentifierIntoString:nil])
                     [scanner WOTest_scanCharacter:NULL]; // scan past "="
-                                
+
                 NSString    *memberType;
                 size_t      largestMember   = 0;
                 while ([scanner WOTest_scanTypeIntoString:&memberType])
                 {
                     size_t memberSize = [self WOTest_maximumEmbeddedSizeForType:memberType];
                     largestMember = MAX(largestMember, memberSize);
-                    
+
                     if (memberSize != 0) // watch out for division by zero
                     {
                         // check for alignment gap
                         if (modulo != 0) // fill alignment gap
                             size += (memberSize - modulo);
                     }
-                    
+
                     size += memberSize;
                 }
-                
+
 #if defined (__i386__) || defined (__ppc64)
-                    
+
                 // Special rules for i386:
                 // 1. Composite data types (structs/arrays/unions) take on the alignment of the member with the highest alignment
-                // 2. Size of composite type is a multiple of its alignment 
+                // 2. Size of composite type is a multiple of its alignment
 
                 // Special rules for ppc64 (equivalent):
                 // 1. Embedding alignment of composite types (array/struct) is same as largest embedding align of members.
                 // 2. Total size of the composite is rounded up to multiple of its embedding alignment.
-                
+
                 // Special rules for ppc: None.
-                
+
                 if (largestMember != 0) // watch out for division by zero
                 {
                     // check for alignment gap
                     if (modulo != 0) // fill alignment gap
                         size += (largestMember - modulo);
                 }
-                        
+
 #endif
-                
+
                 if ([scanner WOTest_scanCharacter:&endMarker] && (endMarker == _C_STRUCT_E) && [scanner isAtEnd])
                     return size; // all done
             }
-                
+
             [NSException raise:NSInternalInconsistencyException format:@"scanner error in sizeForType for type %@", typeString];
         }
         else if ([self WOTest_typeIsUnion:typeString])
         {
             NSScanner *scanner = [NSScanner scannerWithString:typeString];
             unichar startMarker, endMarker;
-            
-            if ([scanner WOTest_scanCharacter:&startMarker] && (startMarker == _C_UNION_B)) 
+
+            if ([scanner WOTest_scanCharacter:&startMarker] && (startMarker == _C_UNION_B))
             {
                 // scan optional identifier
-                if ([scanner WOTest_scanIdentifierIntoString:nil]) 
+                if ([scanner WOTest_scanIdentifierIntoString:nil])
                     [scanner WOTest_scanCharacter:NULL]; // scan past "="
-                
+
                 NSString *memberType;
                 while ([scanner WOTest_scanTypeIntoString:&memberType])
                     // size of union is size of largest type in the union
-                    size = MAX(size, [self WOTest_maximumEmbeddedSizeForType:memberType]); 
-                
+                    size = MAX(size, [self WOTest_maximumEmbeddedSizeForType:memberType]);
+
                 if ([scanner WOTest_scanCharacter:&endMarker] && (endMarker == _C_UNION_E) && [scanner isAtEnd])
                     return size; // all done
             }
-            
+
             [NSException raise:NSInternalInconsistencyException format:@"scanner error in sizeForType for type %@", typeString];
         }
         else if ([self WOTest_typeIsBitfield:typeString])
         else if ([self WOTest_typeIsUnknown:typeString])
         {
             // could be a function pointer, but could be something else
-            [NSException raise:NSInternalInconsistencyException format: @"Cannot calculate buffer size for type %@", typeString]; 
+            [NSException raise:NSInternalInconsistencyException format: @"Cannot calculate buffer size for type %@", typeString];
         }
         else // we officially have no idea whatsoever
-            [NSException raise:NSInternalInconsistencyException 
+            [NSException raise:NSInternalInconsistencyException
                         format:@"Cannot calculate buffer size for unknown type %@", typeString];
     }
-    
-    return size;    
+
+    return size;
 }
 
 /*! Returns YES if \p typeString contains a numeric scalar value (char, int, short, long, long long, unsigned char, unsigned int, unsigned short, unsigned long, unsigned long long, float, double, C99 _Bool). Returns NO if the receiver contains any other type, object or pointer (id, Class, SEL, void, char *, as well as arrays, structures and pointers). */
 + (BOOL)WOTest_typeIsNumericScalar:(NSString *)typeString
 {
     if (!typeString) return NO;
-    return ([self WOTest_typeIsChar:typeString]                || 
+    return ([self WOTest_typeIsChar:typeString]                ||
             [self WOTest_typeIsInt:typeString]                 ||
-            [self WOTest_typeIsShort:typeString]               || 
+            [self WOTest_typeIsShort:typeString]               ||
             [self WOTest_typeIsLong:typeString]                ||
-            [self WOTest_typeIsLongLong:typeString]            || 
+            [self WOTest_typeIsLongLong:typeString]            ||
             [self WOTest_typeIsUnsignedChar:typeString]        ||
-            [self WOTest_typeIsUnsignedInt:typeString]         || 
+            [self WOTest_typeIsUnsignedInt:typeString]         ||
             [self WOTest_typeIsUnsignedShort:typeString]       ||
-            [self WOTest_typeIsUnsignedLong:typeString]        || 
+            [self WOTest_typeIsUnsignedLong:typeString]        ||
             [self WOTest_typeIsUnsignedLongLong:typeString]    ||
-            [self WOTest_typeIsFloat:typeString]               || 
+            [self WOTest_typeIsFloat:typeString]               ||
             [self WOTest_typeIsDouble:typeString]              ||
             [self WOTest_typeIsC99Bool:typeString]);
 }
 {
     if (!typeString) return NO;
     const char *type = [typeString UTF8String];
-    return ((strlen(type) == 1) && *type == _C_SHT);   
+    return ((strlen(type) == 1) && *type == _C_SHT);
 }
 
 + (BOOL)WOTest_typeIsLong:(NSString *)typeString
 {
     if (!typeString) return NO;
     const char *type = [typeString UTF8String];
-    return ((strlen(type) == 1) && *type == _C_LNG);   
+    return ((strlen(type) == 1) && *type == _C_LNG);
 }
 
 + (BOOL)WOTest_typeIsLongLong:(NSString *)typeString
 {
     if (!typeString) return NO;
     const char *type = [typeString UTF8String];
-    return ((strlen(type) == 1) && *type == _C_ULNGLNG);   
+    return ((strlen(type) == 1) && *type == _C_ULNGLNG);
 }
 
 + (BOOL)WOTest_typeIsFloat:(NSString *)typeString
 {
     if (!typeString) return NO;
     const char *type = [typeString UTF8String];
-    return ((strlen(type) == 1) && *type == _C_DBL);   
+    return ((strlen(type) == 1) && *type == _C_DBL);
 }
 
 + (BOOL)WOTest_typeIsC99Bool:(NSString *)typeString
 {
     if (!typeString) return NO;
     const char *type = [typeString UTF8String];
-    return ((strlen(type) == 1) && *type == _C_99BOOL);  
+    return ((strlen(type) == 1) && *type == _C_99BOOL);
 }
 
 + (BOOL)WOTest_typeIsVoid:(NSString *)typeString
     return ((strlen(type) == 1) && *type == _C_UNDEF);
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark High-level test methods
 
 - (BOOL)WOTest_testIsEqualToValue:(NSValue *)otherValue
                 return YES;
 
             @try {
-                if (selfObject && otherObject && [NSObject WOTest_object:selfObject respondsToSelector:@selector(isEqual:)]) 
+                if (selfObject && otherObject && [NSObject WOTest_object:selfObject respondsToSelector:@selector(isEqual:)])
                     return [selfObject isEqual:otherObject];
             }
             @catch (id e) {
             if (strcmp([otherValue objCType], @encode(typeof(nil))) == 0)
             {
                 typeof(nil) nilId = nil;
-                NSValue *nilValue = [NSValue valueWithBytes:&nilId objCType:@encode(typeof(nil))]; 
+                NSValue *nilValue = [NSValue valueWithBytes:&nilId objCType:@encode(typeof(nil))];
                 if ([otherValue WOTest_compare:nilValue] == NSOrderedSame) // comparing other value (nil) with self object
                     return ([self nonretainedObjectValue] == nil);
             }
-            
+
             // will raise exception (comparing numeric scalar with object)
             return ([self WOTest_compare:otherValue] == NSOrderedSame);
         }
     {
         // check for special case: comparing with nil
         typeof(nil) nilId = nil;
-        NSValue *nilValue = [NSValue valueWithBytes:&nilId objCType:@encode(typeof(nil))];         
-        if ((strcmp([self objCType], @encode(typeof(nil))) == 0) && ([self WOTest_compare:nilValue] == NSOrderedSame)) 
+        NSValue *nilValue = [NSValue valueWithBytes:&nilId objCType:@encode(typeof(nil))];
+        if ((strcmp([self objCType], @encode(typeof(nil))) == 0) && ([self WOTest_compare:nilValue] == NSOrderedSame))
         {
             // self is nil (or at least looks like nil)
             if ([otherValue WOTest_isObject])                          // comparing self (nil) with otherObject
             else if ([otherValue WOTest_isPointerToVoid])              // special case can compare to pointer to void if zero
                 return ((id)[otherValue pointerValue] == nil);
         }
-        
+
         // could raise exception (comparing numeric scalar with object)
         return ([self WOTest_compare:otherValue] == NSOrderedSame);
     }
         else if ([otherValue WOTest_isPointerToVoid])
             // this special case already necessary on Leopard, otherwise nil-to-nil comparison fails
             return ([self pointerValue] == [otherValue pointerValue]);
-        
+
         // fall through to standard case
         return ([self WOTest_compare:otherValue] == NSOrderedSame);
     }
-    else if (([self WOTest_isCharArray] || [self WOTest_isCharacterString] || [self WOTest_isConstantCharacterString]) && 
-             ([otherValue WOTest_isCharArray] || [otherValue WOTest_isCharacterString] || 
+    else if (([self WOTest_isCharArray] || [self WOTest_isCharacterString] || [self WOTest_isConstantCharacterString]) &&
+             ([otherValue WOTest_isCharArray] || [otherValue WOTest_isCharacterString] ||
               [otherValue WOTest_isConstantCharacterString]))
     {
         // another special case
 {
     if (!aValue)
         [NSException raise:NSInvalidArgumentException format:@"cannot compare to nil"];
-    
+
     // object case
     if ([self WOTest_isObject])
     {
         if (![aValue WOTest_isObject])
             [NSException raise:NSInvalidArgumentException format:@"cannot compare object with non-object"];
-        
+
         id selfObject   = [self nonretainedObjectValue];
         id otherObject  = [aValue nonretainedObjectValue];
-        
+
         if ([selfObject isKindOfClass:[otherObject class]] && [selfObject respondsToSelector:@selector(compare:)])
-            return ((NSComparisonResult (*)(id, SEL, id))objc_msgSend)(selfObject, @selector(compare:), otherObject); 
+            return ((NSComparisonResult (*)(id, SEL, id))objc_msgSend)(selfObject, @selector(compare:), otherObject);
         else if ([otherObject isKindOfClass:[selfObject class]] && [otherObject respondsToSelector:@selector(compare:)])
             return ((NSComparisonResult (*)(id, SEL, id))objc_msgSend)(otherObject, @selector(compare:), selfObject);
-        
+
         [NSException raise:NSInvalidArgumentException format:@"compared objects must be of same class and implement compare:"];
     }
-    
+
     // numeric scalar case
     if ([self WOTest_isNumericScalar] && [aValue WOTest_isNumericScalar])
     {
         else if ([aValue WOTest_isC99Bool])
             return [self WOTest_compareWithC99Bool:[aValue WOTest_C99BoolValue]];
     }
-    
+
     [NSException raise:NSInvalidArgumentException format:@"non-numeric value(s) passed"];
 
     // never reached, but necessary to suppress compiler warning
-    return NSOrderedSame;  
+    return NSOrderedSame;
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Utility methods
 
 - (size_t)WOTest_bufferSize
 - (void)WOTest_printSignCompareWarning:(NSString *)warning
 {
     NSParameterAssert(warning != nil);
-    
+
     // this conditional in here so that the warnings can be turned off in WOTest self-testing
     if ([[WOTest sharedInstance] warnsAboutSignComparisons])
     {
             if ([NSObject WOTest_object:valueContents isKindOfClass:[NSString class]])
                 return [[valueContents retain] autorelease];
             else if ([NSObject WOTest_object:valueContents respondsToSelector:@selector(description)] &&
-                     [NSObject WOTest_isIdReturnType:[NSObject WOTest_returnTypeForObject:valueContents 
+                     [NSObject WOTest_isIdReturnType:[NSObject WOTest_returnTypeForObject:valueContents
                                                                                  selector:@selector(description)]])
             {
                 NSString *description = objc_msgSend(valueContents, @selector(description));
     else if ([self WOTest_isSelector])
         return [NSString stringWithFormat:@"(SEL)%@", NSStringFromSelector([self WOTest_selectorValue])];
     else if ([self WOTest_isPointerToVoid])
-        return [NSString stringWithFormat:@"(void *)%#08x", [self WOTest_pointerToVoidValue]];    
+        return [NSString stringWithFormat:@"(void *)%#08x", [self WOTest_pointerToVoidValue]];
     return [self description];  // fallback case
 }
 
 
 - (unsigned)WOTest_arrayCount
 {
-    NSAssert([self WOTest_isArray], 
+    NSAssert([self WOTest_isArray],
              @"WOTest_arrayCount sent but receiver does not contain an array");
     NSScanner *scanner = [NSScanner scannerWithString:[self WOTest_objCTypeString]];
     unichar startMarker;
     int count = 0;
-    
+
     // attempt the scan: it should work
-    if (!([scanner WOTest_scanCharacter:&startMarker] && (startMarker == _C_ARY_B) && [scanner scanInt:&count])) 
+    if (!([scanner WOTest_scanCharacter:&startMarker] && (startMarker == _C_ARY_B) && [scanner scanInt:&count]))
         [NSException raise:NSInternalInconsistencyException format:@"scanner error in WOTest_arrayCount"];
 
     return (unsigned)count;
 
 - (NSString *)WOTest_arrayType
 {
-    NSAssert([self WOTest_isArray], @"WOTest_arrayType sent but receiver does not contain an array"); 
+    NSAssert([self WOTest_isArray], @"WOTest_arrayType sent but receiver does not contain an array");
     NSScanner *scanner = [NSScanner scannerWithString:[self WOTest_objCTypeString]];
     [scanner setScanLocation:1];
     NSString *typeString;
     if (!([scanner scanInt:nil] && [scanner WOTest_scanTypeIntoString:&typeString]))
-        [NSException raise:NSInternalInconsistencyException format:@"scanner error in WOTest_arrayType"]; 
+        [NSException raise:NSInternalInconsistencyException format:@"scanner error in WOTest_arrayType"];
     return typeString;
 }
 
     unichar startMarker, flag, endMarker;
     int count;
     return ([scanner WOTest_scanCharacter:&startMarker] && (startMarker == _C_ARY_B) &&
-            [scanner scanInt:&count] && 
-            [scanner WOTest_scanCharacter:&flag] && (flag == _C_CHR) && 
+            [scanner scanInt:&count] &&
+            [scanner WOTest_scanCharacter:&flag] && (flag == _C_CHR) &&
             [scanner WOTest_scanCharacter:&endMarker] && (endMarker == _C_ARY_E) &&
             [scanner isAtEnd]);
 }
 {
     @try {
         if ([self WOTest_isCharacterString] || [self WOTest_isConstantCharacterString])
-            return [NSString stringWithUTF8String:(const char *)[self pointerValue]]; 
+            return [NSString stringWithUTF8String:(const char *)[self pointerValue]];
         else // see if this is a char array
         {
-            NSScanner *scanner = [NSScanner scannerWithString:[self WOTest_objCTypeString]]; 
+            NSScanner *scanner = [NSScanner scannerWithString:[self WOTest_objCTypeString]];
             unichar startMarker, flag, endMarker;
             int count;
-            if ([scanner WOTest_scanCharacter:&startMarker] && 
-                (startMarker == _C_ARY_B) && [scanner scanInt:&count] && 
-                [scanner WOTest_scanCharacter:&flag] && (flag == _C_CHR) && 
+            if ([scanner WOTest_scanCharacter:&startMarker] &&
+                (startMarker == _C_ARY_B) && [scanner scanInt:&count] &&
+                [scanner WOTest_scanCharacter:&flag] && (flag == _C_CHR) &&
                 [scanner WOTest_scanCharacter:&endMarker] && (endMarker == _C_ARY_E) &&
                 [scanner isAtEnd])
             {
                 if (count > 0)
                 {
                     char *buffer = malloc(count * sizeof(char));
-                    NSAssert1(buffer != NULL, @"malloc() failed (size %d)", 
+                    NSAssert1(buffer != NULL, @"malloc() failed (size %d)",
                               (count * sizeof(char)));
                     [self getValue:buffer];
-                    
+
                     // confirm that this is a null-terminated string
                     for (int i = 0; i < count; i++)
                     {
     @catch (id e) {
         // fall through
     }
-    return nil;    
+    return nil;
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Low-level test methods
 
 /* Unfortunately there is a lot of very similar code repeated across these methods but it seems to be a necessary evil (600 lines of necessary evil). Firstly, it's necessary to explicitly declare the type of the right-hand value of the comparison. There are lots of permuations for implicit casts, explicit casts (and warnings), and GCC seems to warn about signed to unsigned comparisons differently depending on the types. */
     else if ([self WOTest_isUnsignedInt])
     {
         [self WOTest_printSignCompareWarning:@"comparison between signed and unsigned, to avoid this warning use an explicit cast"];
-        return WO_COMPARE_SCALARS([self WOTest_unsignedIntValue], (unsigned char)other); // explicit cast 
+        return WO_COMPARE_SCALARS([self WOTest_unsignedIntValue], (unsigned char)other); // explicit cast
     }
     else if ([self WOTest_isUnsignedShort])
         return WO_COMPARE_SCALARS([self WOTest_unsignedShortValue], other); // implicit cast
          return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
 
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
     else if ([self WOTest_isUnsignedInt])
     {
         [self WOTest_printSignCompareWarning:@"comparison between signed and unsigned, to avoid this warning use an explicit cast"];
-        return WO_COMPARE_SCALARS([self WOTest_unsignedIntValue], (unsigned long)other); // explicit cast 
+        return WO_COMPARE_SCALARS([self WOTest_unsignedIntValue], (unsigned long)other); // explicit cast
     }
     else if ([self WOTest_isUnsignedShort])
         return WO_COMPARE_SCALARS([self WOTest_unsignedShortValue], other); // implicit cast
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;       // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
 
     // all other cases
-    [NSException raise:NSInvalidArgumentException  
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
 
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;       // never reached, but necessary to suppress compiler warning
 }
 
     if ([self WOTest_isChar]) // (also BOOL)
     {
         [self WOTest_printSignCompareWarning:@"comparison between signed and unsigned, to avoid this warning use an explicit cast"];
-        return WO_COMPARE_SCALARS((unsigned char)[self WOTest_charValue], other); // explicit cast 
+        return WO_COMPARE_SCALARS((unsigned char)[self WOTest_charValue], other); // explicit cast
     }
     else if ([self WOTest_isInt])
     {
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
 
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // implicit cast
 
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;   // never reached, but necessary to suppress compiler warning
 }
 
         return WO_COMPARE_SCALARS([self WOTest_doubleValue], other); // implicit cast
     else if ([self WOTest_isC99Bool])
         return WO_COMPARE_SCALARS([self WOTest_C99BoolValue], other); // no cast
-    
+
     // all other cases
-    [NSException raise:NSInvalidArgumentException 
+    [NSException raise:NSInvalidArgumentException
                 format:@"cannot compare type \"%s\" with type \"%s\"", [self objCType], @encode(typeof(other))];
-    
+
     return NSOrderedSame;       // never reached, but necessary to suppress compiler warning
 }
 
index 1b66f38ad042bc5976870d11255559c5f3420468..053a492cf1bf8f8a84fef439eeffa612037eb79b 100644 (file)
--- a/TODO.txt
+++ b/TODO.txt
@@ -19,15 +19,15 @@ Think about alternative syntax for mock objects; instead of:
 Consider:
 
     [mock expectSelector:@selector(substringFromIndex:)
-                  return:@"foo" 
+                  return:@"foo"
                arguments:3];
 
 Regressions:
 
-- write WOMultithreadedCrash class for WOTest (regression test for multithreaded low level exception handling failure); for now just 
+- write WOMultithreadedCrash class for WOTest (regression test for multithreaded low level exception handling failure); for now just
 WO_TEST_FAIL
 
-- also write WOLocaleFormatterCrash class (copy and refactor WOLocaleFormatter class and tests so that the WOCommon crash problem 
+- also write WOLocaleFormatterCrash class (copy and refactor WOLocaleFormatter class and tests so that the WOCommon crash problem
 can be manifested  in the WOTest tests); again, for now will just be WO_TEST_FAIL
 
 - for Leopard: use RubyCocoa bridge for writing specs in Ruby
\ No newline at end of file
index 67e0296072e700c775545ee03f45ef669c75c20b..62c3603c11cfb1ba8dfc105735148fdd515d4ad9 100644 (file)
 {
     // description for nil should be "(nil)"
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:nil], @"(nil)");
-    
+
     // NSString objects should be returned as-is
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:@"foo"], @"foo");
-    
+
     // NSNumber is a special case:
     // when an NSValue is initialized with an int NSNumber, the NSValue behaves as though it were initialized with an int
     NSNumber *number = [NSNumber numberWithInt:1];
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:number], @"(int)1");
-    
+
     // other objects should return "description"
     NSButton *button = [[NSButton alloc] init];
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:button], [button description]);
-    
-    // custom classes that do not respond to "description" return class name    
+
+    // custom classes that do not respond to "description" return class name
     WOLightweightRoot *root = [WOLightweightRoot newLightweightRoot];
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:root], @"WOLightweightRoot");
     [root dealloc];
-    
+
     // special case: NSValues that contain NSStrings should return the string
     NSValue *value = [NSValue WOTest_valueWithObject:@"foo"];
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:value], @"foo");
-    
+
     // standard case: other NSValues should return "description"
     NSRange range;
     range.location  = 0; // can't use NSMakeRange (Intel release warnings)
     range.length    = 0;
     value = [NSValue valueWithRange:range];
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:value], [value WOTest_description]);
-    
+
     // pointers to void should be formatted as "(void *)<00000000 >", as returned by WOTest_description
     value = [NSValue valueWithNonretainedObject:@"bar"];
     WO_TEST_EQ([NSObject WOTest_descriptionForObject:value], [value WOTest_description]);
     id object       = @"foo";
     id subobject    = [NSMutableString stringWithString:@"bar"];
     id otherObject  = [WOLightweightRoot newLightweightRoot];
-    
+
     // should raise if passed a non-class pointer
     WO_TEST_THROWS([NSObject WOTest_object:self isKindOfClass:(Class)self]);
     WO_TEST_DOES_NOT_THROW([NSObject WOTest_object:self isKindOfClass:[self class]]);
-    
+
     // nil object or NULL class should always return NO
     WO_TEST_FALSE([NSObject WOTest_object:nil isKindOfClass:NULL]);
     WO_TEST_FALSE([NSObject WOTest_object:self isKindOfClass:NULL]);
     WO_TEST_FALSE([NSObject WOTest_object:nil isKindOfClass:[self class]]);
-    
+
     // basic test cases
     WO_TEST([NSObject WOTest_object:object isKindOfClass:[NSString class]]);
-    WO_TEST_FALSE([NSObject WOTest_object:object isKindOfClass:[NSNumber class]]);        
-    
+    WO_TEST_FALSE([NSObject WOTest_object:object isKindOfClass:[NSNumber class]]);
+
     // subclass should be considered of same kind as superclass
     WO_TEST([NSObject WOTest_object:subobject isKindOfClass:[NSString class]]);
-    
+
     // superclass should not be considered as same kind as subclass
     WO_TEST_FALSE([NSObject WOTest_object:[[[NSObject alloc] init] autorelease]
                      isKindOfClass:[self class]]);
-    
+
     // initial attempt at this test failed because the NSString object had a
     // superclass of "%NSCFString", which happened to match NSMutableString!
     //WO_TEST_FALSE([NSObject WOTest_object:object
     //                 isKindOfClass:[NSMutableString class]]);
     // note that the Cocoa isKindOfClass: method also produces this behaviour:
     //WO_TEST_FALSE([@"constant string" isKindOfClass:[NSMutableString class]]);
-        
+
     // should handle custom root classes without problems
-    WO_TEST([NSObject WOTest_object:otherObject 
+    WO_TEST([NSObject WOTest_object:otherObject
                isKindOfClass:NSClassFromString(@"WOLightweightRoot")]);
     WO_TEST_FALSE([NSObject WOTest_object:otherObject isKindOfClass:[NSString class]]);
-    WO_TEST_FALSE([NSObject WOTest_object:self 
+    WO_TEST_FALSE([NSObject WOTest_object:self
                      isKindOfClass:NSClassFromString(@"WOLightweightRoot")]);
-    
+
     // cleanup
     [otherObject dealloc];
 }
     Class class         = [NSString class];
     Class subclass      = [NSMutableString class];
     Class otherClass    = NSClassFromString(@"WOLightweightRoot");
-    
+
     // should raise if passed non-class pointers
     WO_TEST_THROWS([NSObject WOTest_instancesOfClass:(Class)self areKindOfClass:(Class)self]);
     WO_TEST_THROWS([NSObject WOTest_instancesOfClass:(Class)self areKindOfClass:[NSString class]]);
     WO_TEST_THROWS([NSObject WOTest_instancesOfClass:[NSString class] areKindOfClass:(Class)self]);
     WO_TEST_DOES_NOT_THROW([NSObject WOTest_instancesOfClass:[self class] areKindOfClass:[NSString class]]);
-    
+
     // if either class is NULL should always return NO
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:NULL areKindOfClass:NULL]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[self class] areKindOfClass:NULL]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:NULL areKindOfClass:[self class]]);
-    
+
     // basic tests
     WO_TEST([NSObject WOTest_instancesOfClass:[NSString class] areKindOfClass:[NSString class]]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[NSString class] areKindOfClass:[NSNumber class]]);
-        
+
     // a subclass should be considered of same kind as superclass
     WO_TEST([NSObject WOTest_instancesOfClass:subclass areKindOfClass:class]);
-    
+
     // a superclass should not be considered as same kind as subclass
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:class areKindOfClass:subclass]);
-    
+
     // should handle custom root classes without problems
     WO_TEST([NSObject WOTest_instancesOfClass:otherClass areKindOfClass:otherClass]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:class areKindOfClass:otherClass]);
     id object       = @"foobar";
     id subobject    = [NSMutableString stringWithString:object];
     id root         = [WOLightweightRoot newLightweightRoot];
-    
+
     // test returns NO for nil object or NULL selector
     WO_TEST_FALSE([NSObject WOTest_object:nil respondsToSelector:NULL]);
     WO_TEST_FALSE([NSObject WOTest_object:nil respondsToSelector:@selector(length)]);
     WO_TEST_FALSE([NSObject WOTest_object:self respondsToSelector:NULL]);
-    
+
     // basic tests
-    WO_TEST([NSObject WOTest_object:self 
+    WO_TEST([NSObject WOTest_object:self
           respondsToSelector:@selector(testObjectRespondsToSelector)]);
     WO_TEST_FALSE([NSObject WOTest_object:self respondsToSelector:@selector(foo)]);
-    
+
     // should work for subclasses
     WO_TEST([NSObject WOTest_object:object respondsToSelector:@selector(length)]);
     WO_TEST([NSObject WOTest_object:subobject respondsToSelector:@selector(length)]);
     WO_TEST_FALSE([NSObject WOTest_object:object respondsToSelector:@selector(bar)]);
-    WO_TEST_FALSE([NSObject WOTest_object:subobject 
+    WO_TEST_FALSE([NSObject WOTest_object:subobject
                 respondsToSelector:@selector(bar)]);
-    
+
     // should handle custom root classes without problems
     WO_TEST([NSObject WOTest_object:root respondsToSelector:@selector(dealloc)]);
     WO_TEST_FALSE([NSObject WOTest_object:root respondsToSelector:@selector(foobar)]);
-    
+
     // cleanup
     [root dealloc];
 }
     // should raise if passed non-class pointer
     WO_TEST_THROWS([NSObject WOTest_class:(Class)self respondsToSelector:@selector(init)]);
     WO_TEST_DOES_NOT_THROW([NSObject WOTest_class:[self class] respondsToSelector:@selector(init)]);
-    
+
     // test that NULL class or NULL selector return NO
     WO_TEST_FALSE([NSObject WOTest_class:NULL respondsToSelector:NULL]);
     WO_TEST_FALSE([NSObject WOTest_class:NULL respondsToSelector:@selector(init)]);
     WO_TEST_FALSE([NSObject WOTest_class:[self class] respondsToSelector:NULL]);
-    
+
     // basic tests
     WO_TEST([NSObject WOTest_class:[self class] respondsToSelector:@selector(initialize)]);
     WO_TEST_FALSE([NSObject WOTest_class:[self class] respondsToSelector:@selector(unimplimentedClassMethod)]);
 {
     // should raise if passed non-class pointer
     WO_TEST_THROWS([NSObject WOTest_instancesOfClass:(Class)self respondToSelector:@selector(init)]);
-    WO_TEST_DOES_NOT_THROW([NSObject WOTest_instancesOfClass:[self class] respondToSelector:@selector(init)]);               
-    
+    WO_TEST_DOES_NOT_THROW([NSObject WOTest_instancesOfClass:[self class] respondToSelector:@selector(init)]);
+
     // test that NULL class or NULL selector return NO
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:NULL respondToSelector:NULL]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:NULL respondToSelector:@selector(length)]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[self class] respondToSelector:NULL]);
-    
+
     // basic tests
     WO_TEST([NSObject WOTest_instancesOfClass:[NSString class] respondToSelector:@selector(length)]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[NSString class] respondToSelector:@selector(longitude)]);
-    
+
     // subclasses should work as well
     WO_TEST([NSObject WOTest_instancesOfClass:[NSMutableString class] respondToSelector:@selector(length)]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[NSMutableString class] respondToSelector:@selector(longitude)]);
-    
+
     // should work with custom root classes
     WO_TEST([NSObject WOTest_instancesOfClass:NSClassFromString(@"WOLightweightRoot") respondToSelector:@selector(forward::)]);
     WO_TEST([NSObject WOTest_instancesOfClass:NSClassFromString(@"WOLightweightRoot") respondToSelector:@selector(dealloc)]);
     // should throw if passed non-class pointer
     WO_TEST_THROWS([NSObject WOTest_instancesOfClass:(Class)self conformToProtocol:@protocol(NSLocking)]);
     WO_TEST_DOES_NOT_THROW([NSObject WOTest_instancesOfClass:[self class] conformToProtocol:@protocol(NSObject)]);
-    
+
     // test that NULL class or NULL protocol return NO
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:NULL conformToProtocol:NULL]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[self class] conformToProtocol:NULL]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:NULL conformToProtocol:@protocol(WOTest)]);
-    
+
     // basic tests
     WO_TEST([NSObject WOTest_instancesOfClass:[NSLock class] conformToProtocol:@protocol(NSLocking)]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[NSString class] conformToProtocol:@protocol(NSLocking)]);
     WO_TEST([NSObject WOTest_instancesOfClass:[self class] conformToProtocol:@protocol(WOTest)]);
     WO_TEST_FALSE([NSObject WOTest_instancesOfClass:[self class] conformToProtocol:@protocol(NSTextAttachmentCell)]);
-    
+
     // test with subclasses (subclasses should inherit protocol conformance)
     WO_TEST([NSObject WOTest_instancesOfClass:[NSMutableString class] conformToProtocol:@protocol(NSCopying)]);
-    
+
     // should handle custom root classes
     WO_TEST_FALSE
         ([NSObject WOTest_instancesOfClass:NSClassFromString(@"WOLightweightRoot") conformToProtocol:@protocol(NSLocking)]);
     WO_TEST_THROWS([NSObject WOTest_returnTypeForClass:NULL selector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_returnTypeForClass:NULL selector:@selector(init)]);
     WO_TEST_THROWS([NSObject WOTest_returnTypeForClass:[self class] selector:NULL]);
-    
+
     // raises if passed non-class pointer
     WO_TEST_THROWS([NSObject WOTest_returnTypeForClass:(Class)self selector:@selector(init)]);
-    
+
     // basic test
     WO_TEST_EQ([NSObject WOTest_returnTypeForClass:[self class] selector:@selector(initialize)], @"v");
-    
+
     // returns nil for unrecognized selector
     WO_TEST_EQ([NSObject WOTest_returnTypeForClass:[self class] selector:@selector(poodle)], nil);
 }
     WO_TEST_THROWS([NSObject WOTest_returnTypeForObject:nil selector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_returnTypeForObject:self selector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_returnTypeForObject:nil selector:@selector(init)]);
-    
+
     // basic test
     WO_TEST_EQ([NSObject WOTest_returnTypeForObject:self selector:@selector(init)], @"@");
-    
+
     // returns nil for unrecognized selector
     WO_TEST_EQ([NSObject WOTest_returnTypeForObject:self selector:@selector(beagle:dog:)], nil);
 }
 {
     WO_TEST([NSObject WOTest_isConstantCharacterStringReturnType:@"r*"]);
     WO_TEST_FALSE([NSObject WOTest_isConstantCharacterStringReturnType:@"^v"]);
-    
+
     // passing nil should return NO, not raise an exception
     WO_TEST_FALSE([NSObject WOTest_isConstantCharacterStringReturnType:nil]);
 }
     WO_TEST_THROWS([NSObject WOTest_objectReturnsId:nil forSelector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_objectReturnsId:self forSelector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_objectReturnsId:nil forSelector:@selector(init)]);
-    
+
     // basic tests
     WO_TEST([NSObject WOTest_objectReturnsId:self forSelector:@selector(init)]);
     WO_TEST_FALSE([NSObject WOTest_objectReturnsId:self forSelector:@selector(dealloc)]);
-    
+
     // passing unrecognized selector should return NO, not raise an exception
     WO_TEST_FALSE([NSObject WOTest_objectReturnsId:self forSelector:@selector(initWithChicken:)]);
 }
     WO_TEST_THROWS([NSObject WOTest_objectReturnsCharacterString:nil forSelector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_objectReturnsCharacterString:self forSelector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_objectReturnsCharacterString:nil forSelector:@selector(init)]);
-    
+
     // basic tests
-    char *string = "foo";    
+    char *string = "foo";
     NSValue *value = [NSValue WOTest_valueWithCharacterString:string];
     WO_TEST([NSObject WOTest_objectReturnsCharacterString:value forSelector:@selector(WOTest_characterStringValue)]);
     WO_TEST_FALSE([NSObject WOTest_objectReturnsCharacterString:self forSelector:@selector(init)]);
-    
+
     // passing unrecognized selector should return NO, not raise an exception
     WO_TEST_FALSE([NSObject WOTest_objectReturnsCharacterString:self forSelector:@selector(initWithChicken:)]);
 }
     WO_TEST_THROWS([NSObject WOTest_objectReturnsConstantCharacterString:nil forSelector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_objectReturnsConstantCharacterString:self forSelector:NULL]);
     WO_TEST_THROWS([NSObject WOTest_objectReturnsConstantCharacterString:nil forSelector:@selector(init)]);
-    
+
     // basic tests
     NSValue *value      = [NSValue WOTest_valueWithConstantCharacterString:"foobar"];
     SEL     selector    = @selector(WOTest_constantCharacterStringValue);
     WO_TEST([NSObject WOTest_objectReturnsConstantCharacterString:value forSelector:selector]);
     WO_TEST_FALSE([NSObject WOTest_objectReturnsConstantCharacterString:self forSelector:@selector(init)]);
-    
+
     // passing unrecognized selector should return NO, not raise an exception
     WO_TEST_FALSE([NSObject WOTest_objectReturnsConstantCharacterString:self forSelector:@selector(getTurkey)]);
 }
index bf1410205b0f19d62c75723aca62bcd38d64a31e..a107c2d2e37b710741b0d020488f59013f7ee16c 100644 (file)
@@ -29,7 +29,7 @@
     NSString    *string     = @"foobar";
     NSScanner   *scanner    = [NSScanner scannerWithString:string];
     unichar     character;
-    
+
     WO_TEST_THROWS([scanner WOTest_peekCharacter:NULL]);        // test response to NULL
     [scanner setScanLocation:0];                                // move to start
     WO_TEST([scanner WOTest_peekCharacter:&character]);         // scans
@@ -45,7 +45,7 @@
     NSString    *string     = @"foobar";
     NSScanner   *scanner    = [NSScanner scannerWithString:string];
     unichar     character   = 0;
-    
+
     WO_TEST_DOES_NOT_THROW([scanner WOTest_scanCharacter:NULL]);    // test with NULL
     [scanner setScanLocation:0];                                    // move to start
     WO_TEST_TRUE([scanner WOTest_scanCharacter:&character]);        // scans
 - (void)testScanReturnTypeIntoString
 {
     // handles nil correctly
-    
+
     // return types must be at beginning of string
 }
 
 - (void)testScanTypeIntoString
 {
     // handles nil correctly
-    
-    
-    
+
+
+
 }
 
 - (void)testScanQualifiersIntoString
 {
     // handles nil correctly
-    
+
 }
 
 - (void)testScanNonCompoundTypeIntoString
 {
     // test handles nil correctly
-    
+
 }
 
 - (void)testScanBitfieldIntoString
 {
     // test handles nil correctly
-    
+
 }
 
 - (void)testScanArrayIntoString
 {
     // test handles nil correctly
-    
+
 }
 
 - (void)testScanIdentifierIntoString
 {
     // test handles nil correctly
-    
+
 }
 
 - (void)testScanStructIntoString
 {
     // test handles nil correctly
-    
+
 }
 
 - (void)testScanUnionIntoString
 {
     // test handles nil correctly
-    
+
 }
 
 - (void)testScanPointerIntoString
     NSString    *string     = @"^i";
     NSScanner   *scanner    = [NSScanner scannerWithString:string];
     NSString    *result     = nil;
-    
+
     // test handles nil correctly
     WO_TEST_TRUE([scanner scanPointerIntoString:nil]);
-    
+
     // test scanning a pointer to something
     [scanner setScanLocation:0];
     WO_TEST_TRUE([scanner scanPointerIntoString:&result]);
     WO_TEST_EQUAL(string, result);
-    
+
     // test scanning a pointer to a pointer to something
     string  = @"^^{WOStruct=fi@}";
     scanner = [NSScanner scannerWithString:string];
     result  = nil;
     WO_TEST_TRUE([scanner scanPointerIntoString:&result]);
     WO_TEST_EQUAL(string, result);
-    
+
     // test against a non-pointer
     string  = @"{WOStruct=^fi@}";
     scanner = [NSScanner scannerWithString:string];
         (@"{_NSRect={_NSPoint=ff}{_NSSize=ff}}"
          @"28@0:4{_NSRect={_NSPoint=ff}{_NSSize=ff}}8I24")];
     NSScanner *scanner9 = [NSScanner scannerWithString:@"@12@0:4@8"];
-    
+
     // WOTest_peekCharacter: and WOTest_scanCharacter:
     unichar character;
     [scanner1 WOTest_scanCharacter:&character];
-    WO_TEST_EQUAL(character, '@'); 
+    WO_TEST_EQUAL(character, '@');
     WO_TEST_EQUAL([scanner1 scanLocation], (unsigned)1);        // should advance
     [scanner1 WOTest_peekCharacter:&character];
     WO_TEST_EQUAL(character, '8');
     WO_TEST_FALSE([scanner1 WOTest_peekCharacter:&character]);  // atEnd
     WO_TEST_FALSE([scanner1 WOTest_scanCharacter:&character]);  // atEnd
     [scanner1 setScanLocation:0];                               // reset
-    
+
     // using higher level scanning methods to parse: @8@0:4
     NSString *type;
     WO_TEST_TRUE([scanner1 WOTest_scanNonCompoundTypeIntoString:&type]);
     WO_TEST_FALSE([scanner1 WOTest_scanUnionIntoString:&type]);
     WO_TEST_FALSE([scanner1 scanPointerIntoString:&type]);
     WO_TEST_EQUAL([scanner1 scanLocation], (unsigned)0);    // still at start
-    
+
     // parsing: r*8@0:4
     WO_TEST_FALSE([scanner2 WOTest_scanNonCompoundTypeIntoString:&type]);
     WO_TEST_TRUE([scanner2 WOTest_scanTypeIntoString:&type]);
     WO_TEST_FALSE([scanner2 WOTest_scanUnionIntoString:&type]);
     WO_TEST_FALSE([scanner2 scanPointerIntoString:&type]);
     WO_TEST_EQUAL([scanner2 scanLocation], (unsigned)0);    // still at start
-    
+
     // parse: ^v8@0:4
     type = nil;
     WO_TEST_TRUE([scanner3 WOTest_scanReturnTypeIntoString:&type]);
     WO_TEST_EQUAL(type, @"^v");
-    
+
     // parse: c12@0:4@8
     type = nil;
     WO_TEST_TRUE([scanner4 WOTest_scanReturnTypeIntoString:&type]);
     WO_TEST_EQUAL(type, @"c");
-    
+
     // parse: @12@0:4^{_NSZone=}8
     type = nil;
     WO_TEST_TRUE([scanner5 WOTest_scanReturnTypeIntoString:&type]);
     WO_TEST_EQUAL(type, @"@");
-    
+
     // parse: #8@0:4
     type = nil;
     WO_TEST_TRUE([scanner6 WOTest_scanReturnTypeIntoString:&type]);
     WO_TEST_EQUAL(type, @"#");
-    
+
     // parse: v20@0:4@8:12@16
     type = nil;
     WO_TEST_TRUE([scanner7 WOTest_scanReturnTypeIntoString:&type]);
     WO_TEST_EQUAL(type, @"v");
-    
+
     // parse: {_NSRect={_NSPoint=ff}{_NSSize=ff}}28@0:4{_NSRect={_NSPoint=f...
     type = nil;
     WO_TEST_TRUE([scanner8 WOTest_scanReturnTypeIntoString:&type]);
     WO_TEST_EQUAL(type, @"{_NSRect={_NSPoint=ff}{_NSSize=ff}}");
-    
+
     // parse: @12@0:4@8
     type = nil;
     WO_TEST_TRUE([scanner9 WOTest_scanReturnTypeIntoString:&type]);
index caee9ec0d36c8dc77194bedb038ec76445b4623d..0bfa236ae15a45605aca56e12a87c6ae49e8df97 100644 (file)
@@ -36,7 +36,7 @@ typedef struct WOSubstruct {
     unsigned short      fye;
     NSRect              foe;
     NSPoint             fum;
-} WOSubstruct; 
+} WOSubstruct;
 
 typedef union WOSubunion {
     NSPoint             a;
@@ -76,7 +76,7 @@ typedef union WOComplicatedUnion {
     unsigned int        /* no identifier */ : 6;
     unsigned int        bitfield_d          : 2;
     float               xavier;
-    char                zach;               
+    char                zach;
 } WOComplicatedUnion;
 
 // anonymous struct (no identifier)
@@ -111,7 +111,7 @@ typedef struct {
     unsigned long long  ull;
     float               f;
     double              d;
-    
+
     // pointers etc
     id                  object;
     Class               class;
@@ -120,14 +120,14 @@ typedef struct {
     char                *pChar;
     const char          *pConstChar;
     int                 *pInt;
-    
+
     // compound types
     WOComplicatedStruct aStruct;
     WOComplicatedUnion  aUnion;
-    
+
     // special case: function pointers
     float               (*pFunction)(float, float, float);
-    
+
     // test assumption that @encode() returns the same as @encode(typeof())
     WO_TEST_EQ(@encode(_Bool), @encode(typeof(b)));
     WO_TEST_EQ(@encode(char), @encode(typeof(c)));
@@ -154,7 +154,7 @@ typedef struct {
     WO_TEST_EQ(@encode(float (*)(float, float, float)), @encode(typeof(pFunction)));
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Creation and retrieval convenience methods
 
 - (void)testCharConvenienceMethods
@@ -162,15 +162,15 @@ typedef struct {
     // test valueWithChar
     char aChar = 'a';
     NSValue *value = [NSValue WOTest_valueWithChar:aChar];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(char)); 
-    
+    WO_TEST_EQ([value objCType], @encode(char));
+
     // check that the value extracts as expected
     char extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, aChar);
-    
+
     // also test WOTest_charValue method
     WO_TEST_EQ([value WOTest_charValue], aChar);
 }
@@ -180,15 +180,15 @@ typedef struct {
     // test valueWithInt
     int anInt = 20;
     NSValue *value = [NSValue WOTest_valueWithInt:anInt];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(int)); 
-    
+    WO_TEST_EQ([value objCType], @encode(int));
+
     // check that the value extracts as expected
     int extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, anInt);
-    
+
     // also test WOTest_intValue method
     WO_TEST_EQ([value WOTest_intValue], anInt);
 }
@@ -198,15 +198,15 @@ typedef struct {
     // test valueWithShort
     short aShort = 100;
     NSValue *value = [NSValue WOTest_valueWithShort:aShort];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(short)); 
-    
+    WO_TEST_EQ([value objCType], @encode(short));
+
     // check that the value extracts as expected
     short extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, aShort);
-    
+
     // also test WOTest_shortValue method
     WO_TEST_EQ([value WOTest_shortValue], aShort);
 }
@@ -216,15 +216,15 @@ typedef struct {
     // test valueWithLong
     long aLong = 200;
     NSValue *value = [NSValue WOTest_valueWithLong:aLong];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(long)); 
-    
+    WO_TEST_EQ([value objCType], @encode(long));
+
     // check that the value extracts as expected
     long extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, aLong);
-    
+
     // also test WOTest_longValue method
     WO_TEST_EQ([value WOTest_longValue], aLong);
 }
@@ -234,15 +234,15 @@ typedef struct {
     // test valueWithLongLong
     long long aLongLong = 5;
     NSValue *value = [NSValue WOTest_valueWithLongLong:aLongLong];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(long long)); 
-    
+    WO_TEST_EQ([value objCType], @encode(long long));
+
     // check that the value extracts as expected
     long long extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, aLongLong);
-    
+
     // also test WOTest_longLongValue method
     WO_TEST_EQ([value WOTest_longLongValue], aLongLong);
 }
@@ -252,15 +252,15 @@ typedef struct {
     // test valueWithUnsignedChar
     unsigned char anUnsignedChar = 'a';
     NSValue *value = [NSValue WOTest_valueWithUnsignedChar:anUnsignedChar];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(unsigned char)); 
-    
+    WO_TEST_EQ([value objCType], @encode(unsigned char));
+
     // check that the value extracts as expected
     unsigned char extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, anUnsignedChar);
-    
+
     // also test WOTest_unsignedCharValue method
     WO_TEST_EQ([value WOTest_unsignedCharValue], anUnsignedChar);
 }
@@ -270,15 +270,15 @@ typedef struct {
     // test valueWithUnsignedInt
     unsigned int anUnsignedInt = 100;
     NSValue *value = [NSValue WOTest_valueWithUnsignedInt:anUnsignedInt];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(unsigned int)); 
-    
+    WO_TEST_EQ([value objCType], @encode(unsigned int));
+
     // check that the value extracts as expected
     unsigned int extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, anUnsignedInt);
-    
+
     // also test WOTest_unsignedIntValue method
     WO_TEST_EQ([value WOTest_unsignedIntValue], anUnsignedInt);
 }
@@ -288,15 +288,15 @@ typedef struct {
     // test valueWithUnsignedShort
     unsigned short anUnsignedShort = 40;
     NSValue *value = [NSValue WOTest_valueWithUnsignedShort:anUnsignedShort];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(unsigned short)); 
-    
+    WO_TEST_EQ([value objCType], @encode(unsigned short));
+
     // check that the value extracts as expected
     unsigned short extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, anUnsignedShort);
-    
+
     // also test WOTest_unsignedShortValue method
     WO_TEST_EQ([value WOTest_unsignedShortValue], anUnsignedShort);
 }
@@ -306,15 +306,15 @@ typedef struct {
     // test valueWithUnsignedLong
     unsigned long anUnsignedLong = 2000;
     NSValue *value = [NSValue WOTest_valueWithUnsignedLong:anUnsignedLong];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(unsigned long)); 
-    
+    WO_TEST_EQ([value objCType], @encode(unsigned long));
+
     // check that the value extracts as expected
     unsigned long extracted = 0;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, anUnsignedLong);
-    
+
     // also test WOTest_unsignedLongValue method
     WO_TEST_EQ([value WOTest_unsignedLongValue], anUnsignedLong);
 }
@@ -324,14 +324,14 @@ typedef struct {
     // test valueWithUnsignedLongLong
     unsigned long long anUnsignedLongLong = 20, extracted = 0;
     NSValue *value = [NSValue WOTest_valueWithUnsignedLongLong:anUnsignedLongLong];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(unsigned long long)); 
-    
+    WO_TEST_EQ([value objCType], @encode(unsigned long long));
+
     // check that the value extracts as expected
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, anUnsignedLongLong);
-    
+
     // also test WOTest_unsignedLongLongValue method
     WO_TEST_EQ([value WOTest_unsignedLongLongValue], anUnsignedLongLong);
 }
@@ -341,14 +341,14 @@ typedef struct {
     // test valueWithFloat
     float aFloat = 10.0, extracted = 0.0;
     NSValue *value = [NSValue WOTest_valueWithFloat:aFloat];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(float)); 
-    
+    WO_TEST_EQ([value objCType], @encode(float));
+
     // check that the value extracts as expected
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, aFloat);
-    
+
     // also test WOTest_floatValue method
     WO_TEST_EQ([value WOTest_floatValue], aFloat);
 }
@@ -378,15 +378,15 @@ typedef struct {
     // test valueWithObject
     const char *string = "foo";
     NSValue *value = [NSValue WOTest_valueWithConstantCharacterString:string];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(const char *)); 
-    
+    WO_TEST_EQ([value objCType], @encode(const char *));
+
     // check that the value extracts as expected
     const char *extracted;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, string);
-    
+
     // also test WOTest_constantCharacterStringValue method
     WO_TEST_EQ([value WOTest_constantCharacterStringValue], string);
 }
@@ -396,15 +396,15 @@ typedef struct {
     // test valueWithObject
     char *string = "foo";
     NSValue *value = [NSValue WOTest_valueWithCharacterString:string];
-    
+
     // check type
-    WO_TEST_EQ([value objCType], @encode(char *)); 
-    
+    WO_TEST_EQ([value objCType], @encode(char *));
+
     // check that the value extracts as expected
     char *extracted = NULL;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, string);
-    
+
     // also test WOTest_characterStringValue method
     WO_TEST_EQ([value WOTest_characterStringValue], string);
 }
@@ -415,30 +415,30 @@ typedef struct {
     NSValue *value = [NSValue WOTest_valueWithObject:self];
 
     // check type
-    WO_TEST_EQ([value objCType], @encode(id)); 
-    
+    WO_TEST_EQ([value objCType], @encode(id));
+
     // check that the value extracts as expected
     id extracted = nil;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, self);
-    
+
     // also test WOTest_objectValue method
     WO_TEST_EQ([value WOTest_objectValue], self);
 }
+
 - (void)testClassConvenienceMethods
 {
     // test valueWithClass
     NSValue *value = [NSValue WOTest_valueWithClass:[self class]];
-    
+
     // check type
     WO_TEST_EQ([value objCType], @encode(Class));
-    
+
     // check that the value extracts as expected
     Class extracted = NULL;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, [self class]);
-    
+
     // also test WOTest_classValue method
     WO_TEST_EQ([value WOTest_classValue], [self class]);
 }
@@ -447,15 +447,15 @@ typedef struct {
 {
     // test valueWithSelector
     NSValue *value = [NSValue WOTest_valueWithSelector:_cmd];
-    
+
     // check type
     WO_TEST_EQ([value objCType], @encode(SEL));
-    
+
     // check that the value extracts as expected
     SEL extracted = NULL;
     [value getValue:&extracted];
     WO_TEST_EQ(extracted, _cmd);
-    
+
     // also test WOTest_selectorValue method
     WO_TEST_EQ([value WOTest_selectorValue], _cmd);
 }
@@ -464,7 +464,7 @@ typedef struct {
 {
     // preliminaries
     NSValue *value = nil;
-    
+
     // test with int
     int i = 0;
     value = [NSValue value:&i withObjCType:@encode(int)];
@@ -476,7 +476,7 @@ typedef struct {
     value = [NSValue value:&ui withObjCType:@encode(unsigned int)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(unsigned int));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(unsigned int));
-    
+
     // test with short
     short s = 0;
     value = [NSValue value:&s withObjCType:@encode(short)];
@@ -488,37 +488,37 @@ typedef struct {
     value = [NSValue value:&us withObjCType:@encode(unsigned short)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(unsigned short));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(unsigned short));
-    
+
     // test with long
     long l = 0;
     value = [NSValue value:&l withObjCType:@encode(int)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(int));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(int));
-    
+
     // test with unsigned long
     unsigned long ul = 0;
     value = [NSValue value:&ul withObjCType:@encode(unsigned long)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(unsigned long));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(unsigned long));
-    
+
     // test with long long
     long long ll = 0;
     value = [NSValue value:&ll withObjCType:@encode(long long)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(long long));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(long long));
-    
+
     // test with unsigned long long
     unsigned long long ull = 0;
     value = [NSValue value:&ull withObjCType:@encode(unsigned long long)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(unsigned long long));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(unsigned long long));
-    
+
     // test with float
     float f = 0;
     value = [NSValue value:&f withObjCType:@encode(float)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(float));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(float));
-    
+
     // test with double
     double d = 0;
     value = [NSValue value:&d withObjCType:@encode(double)];
@@ -530,31 +530,31 @@ typedef struct {
     value = [NSValue value:&c withObjCType:@encode(char)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(char));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(char));
-    
+
     // test with unsigned char
     unsigned char uc = 0;
     value = [NSValue value:&uc withObjCType:@encode(unsigned char)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(unsigned char));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(unsigned char));
-    
+
     // test with C99 _Bool
     _Bool b = 0;
     value = [NSValue value:&b withObjCType:@encode(_Bool)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(_Bool));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(_Bool));
-}   
-    
+}
+
 - (void)testSizeCalculationsForStructs
 {
     // preliminaries
     NSValue *value = nil;
 
-    // test with NSRange 
+    // test with NSRange
     NSRange range = NSMakeRange(100, 100);
     value = [NSValue valueWithRange:range];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(NSRange));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(NSRange));
-    
+
     // test with NSPoint
     NSPoint point;
     point.x = 100.0f; // can't use NSMakePoint (warnings on Intel release builds)
@@ -562,30 +562,30 @@ typedef struct {
     value = [NSValue valueWithPoint:point];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(NSPoint));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(NSPoint));
-    
+
     // test with NSRect
     NSRect rect = NSMakeRect(100.0, 100.0, 100.0, 100.0);
     value = [NSValue valueWithRect:rect];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(NSRect));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(NSRect));
-    
+
     // test with simple custom struct
     WOSimpleStruct simple;
     value = [NSValue valueWithBytes:&simple objCType:@encode(WOSimpleStruct)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOSimpleStruct));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOSimpleStruct));
-    
+
     // test with complicated custom structs
     WOSubstruct substruct;
     value = [NSValue valueWithBytes:&substruct objCType:@encode(WOSubstruct)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOSubstruct));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOSubstruct));
-    
+
     WOComplicatedStruct complicated;
     value = [NSValue valueWithBytes:&complicated objCType:@encode(WOComplicatedStruct)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOComplicatedStruct));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOComplicatedStruct));
-    
+
     // test with anonymous struct
     WOAnonymousStruct anonymous;
     value = [NSValue valueWithBytes:&anonymous objCType:@encode(WOAnonymousStruct)];
@@ -603,25 +603,25 @@ typedef struct {
     value = [NSValue valueWithBytes:&simple objCType:@encode(WOSimpleUnion)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOSimpleUnion));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOSimpleUnion));
-    
+
     // test with WOSubunion
     WOSubunion subunion;
     value = [NSValue valueWithBytes:&subunion objCType:@encode(WOSubunion)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOSubunion));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOSubunion));
-    
+
     // test with WOComplicatedUnion
     WOComplicatedUnion complicated;
     value = [NSValue valueWithBytes:&complicated objCType:@encode(WOComplicatedUnion)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOComplicatedUnion));
-    WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOComplicatedUnion));    
+    WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOComplicatedUnion));
 
     // test with anonymous union
     WOAnonymousUnion anonymous;
     value = [NSValue valueWithBytes:&anonymous objCType:@encode(WOAnonymousUnion)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(WOAnonymousUnion));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(WOAnonymousUnion));
-}    
+}
 
 // tests fo id, Class, SEL (really just pointers)
 - (void)testSizeCalculationsForObjects
@@ -634,19 +634,19 @@ typedef struct {
     value = [NSValue valueWithBytes:&i objCType:@encode(id)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(id));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(id));
-    
-    // test with Class 
+
+    // test with Class
     Class c = [self class];
     value = [NSValue valueWithBytes:&c objCType:@encode(Class)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(Class));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(Class));
-    
+
     // test with SEL
     SEL s = _cmd;
     value = [NSValue valueWithBytes:&s objCType:@encode(SEL)];
     WO_TEST_GTE([NSValue WOTest_sizeForType:[value WOTest_objCTypeString]], sizeof(SEL));
     WO_TEST_GTE([value WOTest_bufferSize], sizeof(SEL));
-}    
+}
 
 - (void)testSizeCalculationsForPointers
 {
@@ -654,10 +654,10 @@ typedef struct {
     NSValue *value = nil;
 
     // test with function pointers
-    
-    
-    
-}    
+
+
+
+}
 
 - (void)testSizeCalculationsForArrays
 {
@@ -670,7 +670,7 @@ typedef struct {
 {
     // preliminaries
     NSString            *typeString;
-    
+
     // numeric scalar types
     _Bool               b;
     char                c;
@@ -694,7 +694,7 @@ typedef struct {
     char                *pChar;
     const char          *pConstChar;
     int                 *pInt;
-        
+
     // compound types
     WOComplicatedStruct aStruct;
     WOComplicatedUnion  aUnion;
@@ -702,7 +702,7 @@ typedef struct {
 
     // special case: function pointers
     float               (*pFunction)(float, float, float);
-    
+
     // test type is _Bool
     typeString = [NSString stringWithUTF8String:@encode(typeof(b))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -733,7 +733,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is char
     typeString = [NSString stringWithUTF8String:@encode(typeof(c))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -764,7 +764,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is unsigned char
     typeString = [NSString stringWithUTF8String:@encode(typeof(uc))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -795,7 +795,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is short
     typeString = [NSString stringWithUTF8String:@encode(typeof(s))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -826,7 +826,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is unsigned short
     typeString = [NSString stringWithUTF8String:@encode(typeof(us))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -857,7 +857,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is int
     typeString = [NSString stringWithUTF8String:@encode(typeof(i))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -888,7 +888,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is unsigned int
     typeString = [NSString stringWithUTF8String:@encode(typeof(ui))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -919,7 +919,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is long
     typeString = [NSString stringWithUTF8String:@encode(typeof(l))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -950,7 +950,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is unsigned long
     typeString = [NSString stringWithUTF8String:@encode(typeof(ul))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -981,7 +981,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is long long
     typeString = [NSString stringWithUTF8String:@encode(typeof(ll))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1012,7 +1012,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is unsigned long long
     typeString = [NSString stringWithUTF8String:@encode(typeof(ull))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1043,7 +1043,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is float
     typeString = [NSString stringWithUTF8String:@encode(typeof(f))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1074,7 +1074,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is double
     typeString = [NSString stringWithUTF8String:@encode(typeof(d))];
     WO_TEST([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1105,7 +1105,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is id
     typeString = [NSString stringWithUTF8String:@encode(typeof(object))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1136,7 +1136,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is Class
     typeString = [NSString stringWithUTF8String:@encode(typeof(class))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1167,7 +1167,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is SEL
     typeString = [NSString stringWithUTF8String:@encode(typeof(selector))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1198,7 +1198,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is pointer to void
     typeString = [NSString stringWithUTF8String:@encode(typeof(pVoid))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1229,7 +1229,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is character string
     typeString = [NSString stringWithUTF8String:@encode(typeof(pChar))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1260,7 +1260,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is constant character string
     typeString = [NSString stringWithUTF8String:@encode(typeof(pConstChar))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1291,7 +1291,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is pointer to int
     typeString = [NSString stringWithUTF8String:@encode(typeof(pInt))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1322,7 +1322,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is struct
     typeString = [NSString stringWithUTF8String:@encode(typeof(aStruct))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1353,7 +1353,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is union
     typeString = [NSString stringWithUTF8String:@encode(typeof(aUnion))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1384,7 +1384,7 @@ typedef struct {
     WO_TEST([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is array
     typeString = [NSString stringWithUTF8String:@encode(typeof(anArray))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1415,7 +1415,7 @@ typedef struct {
     WO_TEST_FALSE([NSValue WOTest_typeIsUnion:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsBitfield:typeString]);
     WO_TEST_FALSE([NSValue WOTest_typeIsUnknown:typeString]);
-    
+
     // test type is a function pointer ("^?")
     typeString = [NSString stringWithUTF8String:@encode(typeof(pFunction))];
     WO_TEST_FALSE([NSValue WOTest_typeIsNumericScalar:typeString]);
@@ -1453,7 +1453,7 @@ typedef struct {
     // preliminaries
     BOOL warns = [WO_TEST_SHARED_INSTANCE warnsAboutSignComparisons];
     [WO_TEST_SHARED_INSTANCE setWarnsAboutSignComparisons:NO];
-    
+
     // due to some bad casts, comparing values too large to fit in an unsigned char was failing in specific cases
     // the signed value was being cast to unsigned char in these cases, thus getting truncated
     // this meant that tests would fail with messages like "expected (int)1000, got (unsigned int)1000"
@@ -1463,19 +1463,19 @@ typedef struct {
 
     unsigned long long ullValue = 1000;
     WO_TEST_EQ(ullValue, 1000);         // same bug for unsigned long long compared with int
-    
+
     short shortValue = 1000;
     WO_TEST_EQ(1000U, shortValue);      // same bug for unsigned compared with short
     WO_TEST_EQ(1000UL, shortValue);     // and unsigned long compared with short
     WO_TEST_EQ(ullValue, shortValue);   // and unsigned long long compared with short
-    
+
     WO_TEST_EQ(1000U, 1000L);           // and unsigned int versus long
     WO_TEST_EQ(1000UL, 1000L);          // and unsigned long compared with long
     WO_TEST_EQ(ullValue, 1000L);        // and unsigned long long compared with long
-    
+
     long long llValue = 1000;
     WO_TEST_EQ(ullValue, llValue);      // and unsigned long long compared with long long
-    
+
     // cleanup
     [WO_TEST_SHARED_INSTANCE setWarnsAboutSignComparisons:warns];
 }
index 4a8af49ee68c343f03bdc4f5ebc389ce0ff8d26c..d53d1f6c2d91d2bba0637ef4904661b3366b7265 100644 (file)
 {
     // preliminaries
     WOClassMock *mock = nil;
-    
+
     // should throw if passed NULL
     mock = [WOClassMock alloc];
     WO_TEST_THROWS([mock initWithClass:NULL]);
     [mock release];
-    
+
     // should throw if passed non-class pointer
     mock = [WOClassMock alloc];
     WO_TEST_THROWS([mock initWithClass:(Class)self]);
     [mock release];
-    
+
     // otherwise should work
     WO_TEST_DOES_NOT_THROW
         ([[[WOClassMock alloc] initWithClass:[self class]] autorelease]);
-    
+
     // should throw if passed a meta class
     Class class     = [NSString class];
     Class metaclass = object_getClass(class);
     id mock = [WOClassMock mockForClass:[NSString class]];
     WO_TEST_DOES_NOT_THROW([[mock accept] stringWithString:@"foo"]);
     WO_TEST_DOES_NOT_THROW([mock stringWithString:@"foo"]);
-    
+
     // should throw for instance methods
     WO_TEST_THROWS([[mock accept] lowercaseString]);
-    
+
     // should throw for unknown methods
     WO_TEST_THROWS(objc_msgSend([mock accept], @selector(foobar)));
 }
index 28a4df0f1434d1eace7d465d0348ffec85d69222..6228462cbee9ff11b498b7fbdc642369527068e9 100644 (file)
     //WOObjectMock *mock = [WOMock mockForObjectClass:[NSString class]];
     //[[mock expect] lowercaseString];
     //[mock lowercaseString]; // "warning: 'WOObjectMock' may not respond to '-lowercaseString'"
-    //[mock verify];        
-    
+    //[mock verify];
+
     // one way of avoiding compiler warnings when using mocks: cast to id
     WOObjectMock *mock1 = [WOMock mockForObjectClass:[NSString class]];
     [[mock1 expect] lowercaseString];
     [(id)mock1 lowercaseString];
     [mock1 verify];
-    
+
     // another way of avoiding compiler warnings: use id type from beginning
     id mock2 = [WOMock mockForObjectClass:[NSString class]];
     [[mock2 expect] lowercaseString];
     [mock2 lowercaseString];
     [mock2 verify];
-    
+
     // another way: cast to mocked class
     NSString *mock3 = [WOMock mockForObjectClass:[NSString class]];
     [[(WOMock *)mock3 expect] lowercaseString];
     [mock3 lowercaseString];
     [(WOMock *)mock3 verify];
-    
+
     // another way: alternative way of casting to mocked class
     WOObjectMock *mock4 = [WOMock mockForObjectClass:[NSString class]];
     [[mock4 expect] lowercaseString];
     [(NSString *)mock4 lowercaseString];
     [mock4 verify];
-    
+
     // yet another way: use objc_msgSend
     WOObjectMock *mock5 = [WOMock mockForObjectClass:[NSString class]];
     [[mock5 expect] lowercaseString];
 - (void)testMockForObjectClass
 {
     WOObjectMock *mock = [WOMock mockForObjectClass:[self class]];
-    
+
     // make sure WOObjectMock class is returned
     WO_TEST_EQ([mock class], [WOObjectMock class]);
-    
+
     // make sure mocked class is correctly set
     WO_TEST_EQ([mock mockedClass], [self class]);
-    
+
     // should throw exception instead of entering infinite loop
     WO_TEST_THROWS([WOObjectMock mockForObjectClass:[self class]]);
 }
 - (void)testMockForClass
 {
     WOClassMock *mock = [WOMock mockForClass:[self class]];
-    
+
     // make sure WOClassMock class is returned
     WO_TEST_EQ([mock class], [WOClassMock class]);
-    
+
     // make sure mocked class is correctly set
     Class class     = [self class];
     Class metaclass = object_getClass(class);
     WO_TEST_EQ([mock mockedClass], metaclass);
-    
+
     // should throw exception instead of entering infinite loop
     // cannot test this because subclass implements that method directly
     //WO_TEST_THROWS([WOClassMock mockForClass:[self class]]);
 - (void)testMockForProtocol
 {
     WOProtocolMock *mock = [WOMock mockForProtocol:@protocol(WOTest)];
-    
+
     // make sure WOProtocolMock class is returned
     WO_TEST_EQ([mock class], [WOProtocolMock class]);
-    
+
     // make sure mocked protocol is correctly set
     WO_TEST_EQ([mock mockedProtocol], @protocol(WOTest));
-    
+
     // should throw exception instead of entering infinite loop
     // cannot test this because subclass implements that method directly
     //WO_TEST_THROWS([WOProtocolMock mockForProtocol:@protocol(WOTest)]);
 
 - (void)testInitWithObjectClass
 {
-    WOObjectMock *mock = 
+    WOObjectMock *mock =
         [[[WOMock alloc] initWithObjectClass:[self class]] autorelease];
-    
+
     // make sure WOObjectMock class is returned
     WO_TEST_EQ([mock class], [WOObjectMock class]);
-    
+
     // make sure mocked class is correctly set
     WO_TEST_EQ([mock mockedClass], [self class]);
-    
+
     // should throw exception instead of entering infinite loop
     mock = [WOObjectMock alloc];
     WO_TEST_THROWS([mock initWithObjectClass:[self class]]);
 
 - (void)testInitWithClass
 {
-    WOClassMock *mock = 
+    WOClassMock *mock =
         [[[WOMock alloc] initWithClass:[self class]] autorelease];
-    
+
     // make sure WOClassMock class is returned
     WO_TEST_EQ([mock class], [WOClassMock class]);
-    
+
     // make sure mocked class is correctly set
     Class class     = [self class];
     Class metaclass = object_getClass(class);
     WO_TEST_EQ([mock mockedClass], metaclass);
-    
+
     // should throw exception instead of entering infinite loop
     // cannot test this because subclass implements that method directly
     //mock = [WOClassMock alloc];
 
 - (void)testInitWithProtocol
 {
-    WOProtocolMock *mock = 
+    WOProtocolMock *mock =
         [[[WOMock alloc] initWithProtocol:@protocol(WOTest)] autorelease];
-    
+
     // make sure WOProtocolMock class is returned
     WO_TEST_EQ([mock class], [WOProtocolMock class]);
-    
+
     // make sure mocked protocol is correctly set
     WO_TEST_EQ([mock mockedProtocol], @protocol(WOTest));
-    
+
     // should throw exception instead of entering infinite loop
     // cannot test this because subclass implements that method directly
     //mock = [WOProtocolMock alloc];
index 74d6d04e3095efaa0fb0b2de6852deee49347f7f..c3483b722fa6df0c234386ec10c43f03a3930540 100644 (file)
 - (void)secondaryThreadCrasher:(id)sender
 {
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-    
+
     // Apple's InstallExceptionHandler doesn't catch crashes on secondary threads
     // - in the case of Carbon threads a separate handler is automatically installed for each thread
     // - pthreads and Cocoa threads don't get extra handlers automatically installed
     // - these are per-thread handlers because the per-process handler port is used by the crash reporter
-    
+
     // TODO: write a Mach per-process exception handler
     return;                                                     // don't continue (would crash WOTestRunner)
-    
+
     WO_TEST_PASS;                                               // force update of "lastKnownLocation"
     id *object = NULL;                                          // cause a crash, but WOTest should keep running
     *object = @"foo";                                           // SIGBUS here
index 631c116170121890ded86f2ec819ead17acd1fff..67921c0bdf04309b7420270495877fbe5e2a3ee9 100644 (file)
 
 @implementation WOObjectMockTests
 
-#pragma mark - 
+#pragma mark -
 #pragma mark High-level tests
 
 - (void)testMockForClass
 {
     // should throw if passed NULL
     WO_TEST_THROWS([WOObjectMock mockForClass:NULL]);
-    
+
     // should throw if passed non-class pointer
     WO_TEST_THROWS([WOObjectMock mockForClass:(Class)self]);
-    
+
     // otherwise should work
     WO_TEST_DOES_NOT_THROW([WOObjectMock mockForClass:[self class]]);
-    
+
     // should throw if passed a meta class
     Class class     = [NSString class];
     Class metaclass = object_getClass(class);
 {
     // preliminaries
     WOObjectMock *mock = nil;
-    
+
     // should throw if passed NULL
     mock = [WOObjectMock alloc];
     WO_TEST_THROWS([mock initWithClass:NULL]);
     [mock release];
-    
+
     // should throw if passed non-class pointer
     mock = [WOObjectMock alloc];
     WO_TEST_THROWS([mock initWithClass:(Class)self]);
     [mock release];
-    
+
     // otherwise should work
     WO_TEST_DOES_NOT_THROW
         ([[[WOObjectMock alloc] initWithClass:[self class]] autorelease]);
-    
+
     // should throw if passed a meta class
     Class class     = [NSString class];
     Class metaclass = object_getClass(class);
 {
     // basic test
     id mock = [WOObjectMock mockForClass:[NSString class]];
-    
+
     [[mock expectInOrder] lowercaseString];
     [[mock expectInOrder] uppercaseString];
     [[mock expectInOrder] stringByExpandingTildeInPath];
     [[mock expectInOrder] uppercaseString];
-    
+
     [mock lowercaseString];
     [mock uppercaseString];
     [mock stringByExpandingTildeInPath];
     [mock uppercaseString];
-    
+
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // repeat test: this time omit one of the expected methods
     [mock clear];
     [[mock expectInOrder] lowercaseString];
     [[mock expectInOrder] uppercaseString];
     [[mock expectInOrder] stringByAbbreviatingWithTildeInPath];
     [[mock expectInOrder] uppercaseString];
-    
+
     [mock lowercaseString];
     [mock uppercaseString];
     [mock stringByAbbreviatingWithTildeInPath];
-    
+
     WO_TEST_THROWS([mock verify]);
 
     // repeat test: this time invoke methods in wrong order
     [[mock expectInOrder] uppercaseString];
     [[mock expectInOrder] stringByAbbreviatingWithTildeInPath];
     [[mock expectInOrder] uppercaseString];
-    
+
     [mock lowercaseString];
     WO_TEST_THROWS([mock stringByAbbreviatingWithTildeInPath]);
-    
+
     // test with arguments
     [mock clear];
     [[mock expectInOrder] stringByAppendingFormat:@"foobar"];
     [[mock expectInOrder] uppercaseString];
     [[mock expectInOrder] stringByAbbreviatingWithTildeInPath];
     [[mock expectInOrder] uppercaseString];
-    
+
     [mock stringByAppendingFormat:@"foobar"];
     [mock uppercaseString];
     [mock stringByAbbreviatingWithTildeInPath];
     [mock uppercaseString];
-    
+
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // repeat test: this time pass unexpected argument
     [mock clear];
     [[mock expectInOrder] stringByAppendingFormat:@"foobar"];
     [[mock expectInOrder] uppercaseString];
     [[mock expectInOrder] stringByAbbreviatingWithTildeInPath];
     [[mock expectInOrder] uppercaseString];
-    
+
     WO_TEST_THROWS([mock stringByAppendingFormat:@"other"]);
-    
+
     // test with object return value
     NSValue *value = [NSValue WOTest_valueWithObject:@"foobar"];
     [mock clear];
     [[[mock expectInOrder] returning:value] stringByAppendingString:@"bar"];
     WO_TEST_EQ(@"foobar", [mock stringByAppendingString:@"bar"]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // test with scalar return value
     value = [NSValue WOTest_valueWithUnsignedInt:6];
     [mock clear];
     [[[mock expectInOrder] returning:value] length];
     WO_TEST_EQ((unsigned int)6, [mock length]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // test with raising exception
     [mock clear];
     [[[mock expectInOrder] raising:self] lowercaseString];
     WO_TEST_THROWS([mock lowercaseString]);
-    
+
     // test raising named exception
-    NSException *exception = [NSException exceptionWithName:@"Robert" 
+    NSException *exception = [NSException exceptionWithName:@"Robert"
                                                      reason:@"Robert exception"
                                                    userInfo:nil];
     [mock clear];
     WO_TEST_DOES_NOT_THROW([mock lowercaseString]);
     WO_TEST_THROWS([mock lowercaseString]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // test with arguments
     [mock clear];
     [[mock expectOnce] stringByAppendingFormat:@"foo"];
     WO_TEST_DOES_NOT_THROW([mock stringByAppendingFormat:@"foo"]);
     WO_TEST_THROWS([mock stringByAppendingFormat:@"bar"]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // repeat test: this time pass unexpected argument
     [mock clear];
     [[mock expectOnce] stringByAppendingFormat:@"foo"];
     WO_TEST_THROWS([mock verify]);
     WO_TEST_THROWS([mock stringByAppendingFormat:@"bar"]);
     WO_TEST_THROWS([mock verify]);
-    
+
     // test with return value
     NSValue *value = [NSValue WOTest_valueWithObject:@"foobar"];
     [mock clear];
     WO_TEST_THROWS([mock verify]);
     WO_TEST_EQ(@"foobar", [mock stringByAppendingString:@"bar"]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
+
     // test with raising exception
     [mock clear];
     [[[mock expectOnce] raising:self] lowercaseString];
     WO_TEST_THROWS([mock verify]);
     WO_TEST_THROWS([mock lowercaseString]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // test raising named exception
-    NSException *exception = [NSException exceptionWithName:@"Robert" 
+    NSException *exception = [NSException exceptionWithName:@"Robert"
                                                      reason:@"Robert exception"
                                                    userInfo:nil];
     [mock clear];
     WO_TEST_DOES_NOT_THROW([mock lowercaseString]);
     WO_TEST_DOES_NOT_THROW([mock verify]);
     WO_TEST_THROWS([mock uppercaseString]);
-    
+
     // test with return value (no parameters)
     NSValue *value = [NSValue WOTest_valueWithObject:@".txt"];
     [mock clear];
     [[[mock expect] returning:value] stringByAppendingPathExtension:@"txt"];
     WO_TEST_EQ([mock stringByAppendingPathExtension:@"txt"], @".txt");
     WO_TEST_DOES_NOT_THROW([mock verify]);
-    
+
     // test with parameters and return value
     [mock clear];
     value = [NSValue WOTest_valueWithObject:@"foo.txt"];
     [[[mock expect] returning:value] stringByAppendingFormat:@".txt"];
     WO_TEST_EQ([mock stringByAppendingFormat:@".txt"], @"foo.txt");
     WO_TEST_THROWS([mock stringByAppendingFormat:@".m"]); // wrong argument
-    
+
     // test with parameters but without return value
     [mock clear];
     [[mock expect] stringByAppendingFormat:@".mov"];
     id mock = [WOObjectMock mockForClass:[NSString class]];
     [[mock acceptOnce] lowercaseString];
     WO_TEST_DOES_NOT_THROW([mock lowercaseString]);
-    WO_TEST_THROWS([mock lowercaseString]);        
-    
+    WO_TEST_THROWS([mock lowercaseString]);
+
     // test with arguments
     [mock clear];
     [[mock acceptOnce] stringByAppendingFormat:@"foo"];
     WO_TEST_DOES_NOT_THROW([mock stringByAppendingFormat:@"foo"]);
     WO_TEST_THROWS([mock stringByAppendingFormat:@"foo"]);
-    
+
     // repeat test: this time pass unexpected argument
     [mock clear];
     [[mock acceptOnce] stringByAppendingFormat:@"foo"];
     WO_TEST_THROWS([mock stringByAppendingFormat:@"bar"]);
     WO_TEST_DOES_NOT_THROW([mock stringByAppendingFormat:@"foo"]);
-    WO_TEST_THROWS([mock stringByAppendingFormat:@"foo"]);          
-    
+    WO_TEST_THROWS([mock stringByAppendingFormat:@"foo"]);
+
     // test with return value
     NSValue *value = [NSValue WOTest_valueWithObject:@"foobar"];
     [mock clear];
     [[[mock acceptOnce] returning:value] stringByAppendingFormat:@"bar"];
-    WO_TEST_EQ([mock stringByAppendingFormat:@"bar"], @"foobar");    
+    WO_TEST_EQ([mock stringByAppendingFormat:@"bar"], @"foobar");
     WO_TEST_THROWS([mock stringByAppendingFormat:@"bar"]);
-    
+
     // test raising exception
     [mock clear];
     [[[mock acceptOnce] raising:@"foo"] lowercaseString];
     WO_TEST_THROWS([mock lowercaseString]);
-    
+
     // test raising named exception
-    NSException *exception = [NSException exceptionWithName:@"Robert" 
+    NSException *exception = [NSException exceptionWithName:@"Robert"
                                                      reason:@"Robert exception"
-                                                   userInfo:nil];    
+                                                   userInfo:nil];
     [mock clear];
     [[[mock acceptOnce] raising:exception] lowercaseString];
     WO_TEST_THROWS_EXCEPTION_NAMED([mock lowercaseString], @"Robert");
 {
     // preliminaries
     id mock = nil;
-    
+
     // should throw (NSString instances do not respond to -stringWithString)
     // they do respond to the +stringWithString class method
     mock = [WOObjectMock mockForClass:[NSString class]];
     WO_TEST_THROWS([[mock accept] stringWithString:@"Hello"]);
     WO_TEST_THROWS([mock stringWithString:@"Hello"]);
-    
+
     // should throw even for valid selectors if you haven't set them up first
     mock = [WOObjectMock mockForClass:[NSString class]];
     [[mock expect] lowercaseString];        // a valid NSString selector
     WO_TEST_DOES_NOT_THROW([mock retain]);  // ok (inherited from NSProxy)
     WO_TEST_DOES_NOT_THROW([mock release]); // ok (inherited from NSProxy)
     WO_TEST_THROWS([mock uppercaseString]); // fail (not explicitly expected)
-    
+
     // should throw for class methods
     mock = [WOObjectMock mockForClass:[NSString class]];
     WO_TEST_THROWS([[mock expect] stringWithString:@"foo"]);
     WO_TEST_DOES_NOT_THROW([mock lowercaseString]); // you like... should work
     [mock clear];
     WO_TEST_THROWS([mock lowercaseString]);         // but fail on clear
-    
+
     // should be able to clear and re-set the same selector (was a bug)
     [[mock accept] lowercaseString];
     WO_TEST_DOES_NOT_THROW([mock lowercaseString]);
     [[mock accept] lowercaseString];
     WO_TEST_DOES_NOT_THROW([mock lowercaseString]);
     [mock clear];
-    
+
     // same for acceptOnce
     [[mock acceptOnce] lowercaseString];
     [mock clear];
     WO_TEST_THROWS([mock lowercaseString]);
-    
+
     // expect
     [[mock expect] lowercaseString];
     [mock clear];
     WO_TEST_THROWS([mock lowercaseString]);
-    
+
     // expectOnce
     [[mock expectOnce] lowercaseString];
     [mock clear];
     WO_TEST_THROWS([mock lowercaseString]);
-    
+
     // expectInOrder
     [[mock expectInOrder] lowercaseString];
     [mock clear];
     WO_TEST_THROWS([mock stringByAppendingString:@"bar"]);
     WO_TEST_DOES_NOT_THROW([mock stringByAppendingString:@"foo"]);
     WO_TEST_THROWS([mock stringByAppendingString:nil]);
-    
+
     // but should also be able to accept any argument
     [mock clear];
     [[[mock accept] anyArguments] stringByAppendingString:@"irrelevant"];
 
     // unrecognised selector should always throw
     WO_TEST_THROWS(objc_msgSend(mock, @selector(foobar)));
-    
+
     [mock setAcceptsByDefault:NO];
     WO_TEST_THROWS([mock lowercaseString]);
 }
     WO_TEST_EQ([mock length], (unsigned int)20);
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Low-level tests
 
 - (void)testMock
 {
     // preliminaries
     Class aClass = [self class];
-    
+
     // should raise if passed nil class
     WO_TEST_THROWS([WOObjectMock mockForClass:nil]);
     WO_TEST_THROWS([[[WOObjectMock alloc] initWithClass:nil] release]);
     WO_TEST_DOES_NOT_THROW([WOObjectMock mockForClass:aClass]);
     WO_TEST_DOES_NOT_THROW([[[WOObjectMock alloc] initWithClass:aClass] release]);
-    
+
     // test if passed a non-class object (ie. an instance)
-    
-    // 
+
+    //
 }
 
 - (void)testObjectStub
     // preliminaries
     id      stub    = nil;
     Class   aClass  = [self class];
-    
+
     // raise if initialized with nil class pointer
     WO_TEST_DOES_NOT_THROW([WOObjectStub stubForClass:aClass withDelegate:nil]);
     WO_TEST_THROWS([WOObjectStub stubForClass:nil withDelegate:nil]);
     WO_TEST_DOES_NOT_THROW([[[WOObjectStub alloc] initWithClass:aClass delegate:nil] release]);
     WO_TEST_THROWS([[[WOObjectStub alloc] initWithClass:nil delegate:nil] release]);
-    
+
     // test if passed a non-class object (ie. an instance)
-    
 
-    
+
+
     // shouldn't crash even if passed non-NSObject descendant
-    
-    
+
+
     // test hashes
-    
+
     // make sure methodSignatureForSelector: doesn't go into an infinite loop
-    stub = [WOObjectStub stubForClass:[WOObjectStub class] withDelegate:nil]; 
+    stub = [WOObjectStub stubForClass:[WOObjectStub class] withDelegate:nil];
     SEL selector = @selector(methodSignatureForSelector:);
     WO_TEST_EQUAL([stub methodSignatureForSelector:selector], nil);
-    
+
     // not with subclasses either
-    
-        
+
+
     // raise if returning: is invoked twice
     stub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     [stub lowercaseString];
     WO_TEST_DOES_NOT_THROW([stub returning:@"foo"]);
     WO_TEST_THROWS([stub returning:@"bar"]);
-    
+
     // raise if sent new message when message previously recorded
     stub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     WO_TEST_DOES_NOT_THROW([stub lowercaseString]);
     WO_TEST_THROWS([stub lowercaseString]);
-    
+
     // raise if recordedInvocation called but no message previously recorded
     WO_TEST_DOES_NOT_THROW(stub = [WOObjectStub stubForClass:aClass withDelegate:nil]);
     WO_TEST_THROWS([stub recordedInvocation]);
-    
+
     // test automatic verify on dealloc
 }
 
     WOObjectStub *stub        = nil;
     WOObjectStub *otherStub   = nil;
     Class   aClass      = [self class];
-    
+
     // pointer equality
     stub = [WOObjectStub stubForClass:aClass withDelegate:nil];
     WO_TEST_EQUAL(stub, stub);
     WO_TEST_TRUE([stub isEqual:stub]); // another way to write the same test
-    
+
     // compare against non-stub class
     stub = [WOObjectStub stubForClass:aClass withDelegate:nil];
     otherStub = (WOObjectStub *)@"foobar";
     WO_TEST_NOT_EQUAL(stub, otherStub);
     WO_TEST_FALSE([stub isEqual:otherStub]);
-    
+
     // comparison with nil
     stub = [WOObjectStub stubForClass:aClass withDelegate:nil];
     WO_TEST_NOT_EQUAL(stub, nil);
     WO_TEST_NOT_EQUAL(nil, stub);
     WO_TEST_FALSE([stub isEqual:nil]);
-    
+
     // same class, different instance
     stub = [WOObjectStub stubForClass:aClass withDelegate:nil];
     otherStub = [WOObjectStub stubForClass:aClass withDelegate:nil];
     WO_TEST_EQUAL(stub, otherStub);
     WO_TEST_TRUE([stub isEqual:otherStub]);
-    
+
     // stubs with mismatching classes
     stub = [WOObjectStub stubForClass:aClass withDelegate:nil];
     otherStub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     // mismatching invocations
 
     // mismatching return values
-    
-    
+
+
 }
 
 - (void)testNonExistentSelector
 {
     WO_TEST_START;
-    
+
     id mock = [WOObjectMock mockForClass:[NSString class]];
     [mock setObjCTypes:@"@@:@" forSelector:@selector(totallyRandom:)];
 
     // this causes a compiler warning
     //[[[mock expect] returning:[NSValue WOTest_valueWithObject:@"bar"]] totallyRandom:@"foo"];
-    
+
     // so do it this way instead
     id stub = [[mock expect] returning:[NSValue WOTest_valueWithObject:@"bar"]];
     objc_msgSend(stub, @selector(totallyRandom:), @"foo");
-    
+
     // likewise, this causes a warning
-    //WO_TEST_EQ([mock totallyRandom:@"foo"], @"bar");    
-    
+    //WO_TEST_EQ([mock totallyRandom:@"foo"], @"bar");
+
     // so do it like this:
     WO_TEST_EQ(objc_msgSend(mock, @selector(totallyRandom:), @"foo"), @"bar");
 }
index a51d5d3b39204705376f0427c8890635d6832ed7..84b7311523c3c8fc6072387d76f78162cf5f8776 100644 (file)
     id              mock    = nil;
     WOObjectStub    *stub   = nil;
     NSValue         *value  = [NSValue WOTest_valueWithObject:@"foobar"];
-    
+
     // should raise if returning: invoked but return value already recorded
     stub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     WO_TEST_DOES_NOT_THROW([stub returning:value]);
     WO_TEST_THROWS([stub returning:value]);
-    
+
     // should return expected value
     mock = [WOObjectMock mockForClass:[NSString class]];
     [[[mock accept] returning:value] lowercaseString];
     NSException *exception = [NSException exceptionWithName:@"WOFooException"
                                                      reason:@"foo exception"
                                                    userInfo:nil];
-    
+
     // should raise if raising: invoked but exception already recorded
     stub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     WO_TEST_DOES_NOT_THROW([stub raising:exception]);
     WO_TEST_THROWS([stub raising:exception]);
-    
+
     // try with different kind of exception object (not NSException)
     stub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     WO_TEST_DOES_NOT_THROW([stub raising:@"foo"]);
     WO_TEST_THROWS([stub raising:@"bar"]);
-    
-    // should raise if raising: passed an object that does not respond to 
+
+    // should raise if raising: passed an object that does not respond to
     // retain, release or autorelease
     WOLightweightRoot *root = [WOLightweightRoot newLightweightRoot];
     stub = [WOObjectStub stubForClass:[NSString class] withDelegate:nil];
     WO_TEST_THROWS([stub raising:root]);
     [root dealloc];
-    
+
     // should raise expected exception
     mock = [WOObjectMock mockForClass:[NSString class]];
     [[[mock accept] raising:exception] lowercaseString];
index d58f59afeef9b21358faca6bfdb28a0bd4c50116..d2400ba96f2ad901dbbef6b0e02d3e51fa64ef04 100644 (file)
@@ -36,7 +36,7 @@
     WOProtocolStub *stub = [WOProtocolStub alloc];
     WO_TEST_THROWS([stub initWithProtocol:NULL delegate:nil]);
     [stub dealloc];
-    
+
     // otherwise works
     stub = [WOProtocolStub alloc];
     WO_TEST_DOES_NOT_THROW([stub initWithProtocol:@protocol(WOTest) delegate:nil]);
@@ -46,7 +46,7 @@
 - (void)testMethodSignatureForSelector
 {
     // throws if selector not present in protocol, otherwise works
-    WOProtocolStub *stub = 
+    WOProtocolStub *stub =
         [WOProtocolStub stubForProtocol:@protocol(NSCopying) withDelegate:nil];
     WO_TEST_THROWS([stub methodSignatureForSelector:@selector(retain)]);
     WO_TEST_DOES_NOT_THROW
index 5e82c92e82f0db3be65419ca8ce06cd56f04bcd9..076ab513429b7a66443bc52e28bb1731a598115b 100644 (file)
 
     // raises if sent nil
     WO_TEST_THROWS([stub matchesInvocation:nil]);
-    
+
     // raises if no recorded invocation
     NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:
         [self methodSignatureForSelector:@selector(testMatchesInvocation)]];
     WO_TEST_THROWS([stub matchesInvocation:invocation]);
     [stub setInvocation:invocation];
     WO_TEST_DOES_NOT_THROW([stub matchesInvocation:invocation]);
-    
+
     // test strict matching
-    
-    
+
+
     // test loose matching (arguments not checked)
-    
-    
+
+
 }
 
 @end
index 8131c5f2975366900a6649c90b025e6fab62e704..0a0e9440852f6ccad396a6cbf163751f2e86851d 100644 (file)
@@ -3,7 +3,7 @@
 //  WOTest
 //
 //  Created by Wincent Colaiuta on 15 December 2006.
-// 
+//
 //  Copyright 2006-2007 Wincent Colaiuta.
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
index 4a5b691b70f2a04c8222146a3c05e28d4a989fcf..d31cb3c4f786465c0c5d3495e7ac5aeccd035c0e 100644 (file)
@@ -41,7 +41,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 {
     WOEmptyClassMethodInvocations =
         [[NSMutableArray alloc] initWithCapacity:3];
-    WOEmptyInstanceMethodInvocations = 
+    WOEmptyInstanceMethodInvocations =
         [[NSMutableArray alloc] initWithCapacity:3];
 }
 
@@ -50,7 +50,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // cleanup
     [WOEmptyClassMethodInvocations autorelease];
     [WOEmptyInstanceMethodInvocations autorelease];
-    
+
     // were class methods called in order?
     NSArray *expectedClassMethods = [NSArray arrayWithObjects:
             @"preflight", @"testClassMethod", @"postflight", nil];
@@ -67,7 +67,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 }
 
 + (void)preflight
-{ 
+{
     [WOEmptyClassMethodInvocations addObject:NSStringFromSelector(_cmd)];
 }
 
@@ -81,7 +81,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     [WOEmptyClassMethodInvocations addObject:NSStringFromSelector(_cmd)];
 }
 
-- (void)preflight           
+- (void)preflight
 {
     [WOEmptyInstanceMethodInvocations addObject:NSStringFromSelector(_cmd)];
 }
@@ -111,8 +111,8 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 
 + (id)new
 {
-       Class class = object_getClass(self);
-       return class_createInstance(class, 0);
+    Class class = object_getClass(self);
+    return class_createInstance(class, 0);
 }
 
 - (void)dealloc
@@ -126,16 +126,16 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 - forward:(SEL)sel :(marg_list)args
 {
     return self; // although it behaves equally if I return nil here
-    
+
     /*
-     
+
      TODO: figure out how to make it crash if you send it a selector it doesn't recognize
-     
+
      [Object crashes];      // crashes
      [Protocol foobar];     // crashes (inherits behavior from Object)
      [NSObject foobar];     // raises exception, selector not recognized
      [WORootClass foobar];  // continues execution, no warning
-     
+
     */
 }
 
@@ -150,12 +150,12 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 {
     // seeding with 1 produces repeatable test results across runs
     [WO_TEST_SHARED_INSTANCE seedRandomNumberGenerator:1];
-        
+
     // TODO: set up mock object here to expect that +testClassMethods gets run
 }
 
 + (void)testClassMethods
-{   
+{
     // make sure that class methods run (not just instance methods)
     // TODO: do I need a mock object here to test that the test is run?
     WO_TEST_PASS;
@@ -212,12 +212,12 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 
     NSSet *actualMethods =[NSSet setWithArray:
         [WO_TEST_SHARED_INSTANCE testableMethodsFrom:[self class]]];
-    
+
     WO_TEST_EQ(expectedMethods, actualMethods);
     //WO_TEST_ARRAYS_EQUAL(expectedMethods, actualMethods);
     // TODO: write WO_TEST_SETS_EQUAL
     // TODO: write shorthand macros for like WO_TEST_ARRAYS_EQ
-    
+
     WO_TEST_THROWS([WO_TEST_SHARED_INSTANCE runTestsForClassName:nil]);
     WO_TEST_THROWS([WO_TEST_SHARED_INSTANCE runTestsForClass:nil]);
 }
@@ -226,7 +226,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 {
     // should throw (but not crash) when passed an "id" instead of a "Class"
     WO_TEST_THROWS([WO_TEST_SHARED_INSTANCE testableMethodsFrom:(Class)self]);
-    
+
     // should find class and instance methods beginning with "test"
     NSSet *expectedMethods = [NSSet setWithObjects:
         @"+testClassMethod", @"-testInstanceMethod", nil];
@@ -238,14 +238,14 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 - (void)testPreAndPostflightMethods
 {
     /*
-     
+
      Testing whether methods get called in order requires some tricky runtime
      hackery. First of all we start with the WOEmpty class which is not marked
      with the WOTest protocol. This prevents its test methods from being run
      until we are ready to run them.
-     
+
      We then add the marker protocol at runtime so that the tests can be run.
-     
+
      It would be nice to be able to use mock objects to verify that the methods
      on the WOEmpty class are being called but unfortunately it's not possible
      for two reasons: firstly, mock objects are just that (objects) whereas the
@@ -253,23 +253,23 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
      test running methods work at a very low level in the runtime we can't just
      use a WOClassMock -- once again, a class mock is just an object whereas the
      low-level test running methods work directly with classes in the runtime.
-     
+
      TODO: use objc_allocateClassPair() to create classes on the fly (better class mock implementation)
-                
+
      So we unfortunately have to upgrade WOEmpty to be a real stub and we can't
      benefit from the shortcuts provided by the WOMock cluster.
-     
+
      The runtime hackery cannot be avoided by labelling the WOEmpty class with
      the WOTest marker at compile time because we have no way of knowing the
      order in which classes will be tested and so we cannot know when to fire
      the verify method. The hackery is the only way in which we can have total
      control over the timing of the WOEmpty tests.
-     
+
      */
-    
+
      // confirm that WOEmpty does not conform to protocol
      NSAssert([WOEmpty conformsToProtocol:@protocol(WOTest)] == NO, @"WOEmpty already conforms to WOTest protocol");
-     
+
      // build new protocol entry
      Protocol *protocol = @protocol(WOTest);
      struct objc_protocol_list *new;
@@ -277,9 +277,9 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
      NSAssert1(new != NULL, @"calloc() failed (size %d)", sizeof(struct objc_protocol_list));
      new->count = 1;
      new->list[0] = protocol;
-        NSAssert(class_addProtocol([WOEmpty class], protocol), @"class_addProtocol failed");
-        NSAssert([WOEmpty conformsToProtocol:@protocol(WOTest)], @"WOEmpty class does not conform to WOTest protocol");
-       
+     NSAssert(class_addProtocol([WOEmpty class], protocol), @"class_addProtocol failed");
+     NSAssert([WOEmpty conformsToProtocol:@protocol(WOTest)], @"WOEmpty class does not conform to WOTest protocol");
+
      // perform the actual "tests" (even though WOEmpty contains no real tests)
      [WO_TEST_SHARED_INSTANCE runTestsForClass:[WOEmpty class]];
      WO_TEST_DOES_NOT_THROW([WOEmpty verify]);
@@ -295,7 +295,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 {
     // should pass
     WO_TEST_PASS;
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
     WO_TEST_FAIL;
@@ -303,17 +303,17 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 }
 
 - (void)testBooleanTests
-{   
+{
     // should pass
     WO_TEST_TRUE(YES);
     WO_TEST_FALSE(NO);
 
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
-    
+
     WO_TEST_TRUE(NO);
     WO_TEST_FALSE(YES);
-    
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO];
 }
 
@@ -335,10 +335,10 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     NSArray     *array4     = [NSArray array];
     NSArray     *array5     = nil;
     NSArray     *array6     = nil;
-    
+
     WO_TEST_EQUAL(string1, string2);
     WO_TEST_EQUAL(string2, string1);        // order shouldn't matter
-    WO_TEST_EQUAL(string5, string6);        // nil equals nil 
+    WO_TEST_EQUAL(string5, string6);        // nil equals nil
     WO_TEST_EQUAL(nil, nil);
     WO_TEST_EQUAL(nil, string5);
     WO_TEST_EQUAL(string5, nil);
@@ -354,7 +354,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(string5, string4);
     WO_TEST_NOT_EQUAL(string5, string3);
     WO_TEST_NOT_EQUAL(string3, string5);
-    
+
     WO_TEST_EQUAL(array1, array2);
     WO_TEST_EQUAL(array2, array1);
     WO_TEST_EQUAL(array5, array6);
@@ -368,16 +368,16 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(array5, array4);
     WO_TEST_NOT_EQUAL(array5, array3);
     WO_TEST_NOT_EQUAL(array3, array5);
-    
+
     WO_TEST_EQUAL(string5, array5);         // (id)nil == (id)nil
     WO_TEST_EQUAL(array5, string5);
     WO_TEST_NOT_EQUAL(string4, array4);
-    WO_TEST_NOT_EQUAL(array4, string4);    
+    WO_TEST_NOT_EQUAL(array4, string4);
     WO_TEST_NOT_EQUAL(string2, array2);
     WO_TEST_NOT_EQUAL(array2, string2);
-    WO_TEST_NOT_EQUAL(string1, array1);              
+    WO_TEST_NOT_EQUAL(string1, array1);
     WO_TEST_NOT_EQUAL(array1, string1);
-    
+
     // class objects
     Class class1 = [NSString class];
     Class class2 = [NSString class];
@@ -385,7 +385,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     Class class4 = [NSDictionary class];
     Class class5 = nil;
     Class class6 = nil;
-    
+
     WO_TEST_EQUAL(class1, class2);
     WO_TEST_EQUAL(class2, class1);      // order shouldn't matter
     WO_TEST_EQUAL(class5, class6);      // nil equals nil
@@ -396,21 +396,21 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(class4, class3);
     WO_TEST_NOT_EQUAL(class4, class5);
     WO_TEST_NOT_EQUAL(class5, class4);
-    
+
     WO_TEST_NOT_EQUAL(string5, class5); // different types (even if both nil)
     WO_TEST_NOT_EQUAL(class5, string5);
     WO_TEST_NOT_EQUAL(string1, class1); // class obj is not an instance obj
     WO_TEST_NOT_EQUAL(class1, string1);
     WO_TEST_NOT_EQUAL(string4, class1); // even if instance obj is empty
     WO_TEST_NOT_EQUAL(class1, string4);
-    
+
     // selectors
     SEL selector1   = @selector(stringWithString:);
     SEL selector2   = @selector(stringWithString:);
     SEL selector3   = @selector(init);
     SEL selector4   = NULL;
     SEL selector5   = NULL;
-        
+
     WO_TEST_EQUAL(selector1, selector2);
     WO_TEST_EQUAL(selector2, selector1);
     WO_TEST_NOT_EQUAL(selector2, selector3);
@@ -419,8 +419,8 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(selector4, selector3);
     WO_TEST_EQUAL(selector4, selector5);
     WO_TEST_EQUAL(selector5, selector4);
-    
-    WO_TEST_NOT_EQUAL(selector1, class1);   // different types 
+
+    WO_TEST_NOT_EQUAL(selector1, class1);   // different types
     WO_TEST_NOT_EQUAL(class1, selector1);
     WO_TEST_NOT_EQUAL(selector1, string1);
     WO_TEST_NOT_EQUAL(string1, selector1);
@@ -428,7 +428,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(class5, selector5);
     WO_TEST_NOT_EQUAL(selector5, string6);
     WO_TEST_NOT_EQUAL(string6, selector5);
-    
+
     // values of matching types
     char char1 = 'a';
     char char2 = 'a';
@@ -453,8 +453,8 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(int3, int2);
 
     // need to test all of the different kinds of casts
-    
-    
+
+
     // char, char
     // char, int
     // char, short
@@ -469,9 +469,9 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // char, double
     // char, C99 _Bool
     // char, void *
-    // char, char * 
-    
-    
+    // char, char *
+
+
     // int, char
     // int, int
     // int, short
@@ -486,8 +486,8 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // int, double
     // int, C99 _Bool
     // int, void *
-    // int, char * 
-    
+    // int, char *
+
     // short, char
     // short, int
     // short, short
@@ -502,8 +502,8 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // short, double
     // short, C99 _Bool
     // short, void *
-    // short, char * 
-    
+    // short, char *
+
     // long, char
     // long, int
     // long, short
@@ -518,7 +518,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // long, double
     // long, C99 _Bool
     // long, void *
-    // long, char * 
+    // long, char *
 
     // long long, char
     // long long, int
@@ -534,7 +534,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // long long, double
     // long long, C99 _Bool
     // long long, void *
-    // long long, char * 
+    // long long, char *
 
     // unsigned char, char
     // unsigned char, int
@@ -550,7 +550,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // unsigned char, double
     // unsigned char, C99 _Bool
     // unsigned char, void *
-    // unsigned char, char * 
+    // unsigned char, char *
 
     // unsigned int, char
     // unsigned int, int
@@ -566,7 +566,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // unsigned int, double
     // unsigned int, C99 _Bool
     // unsigned int, void *
-    // unsigned int, char * 
+    // unsigned int, char *
 
     // unsigned short, char
     // unsigned short, int
@@ -582,7 +582,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // unsigned short, double
     // unsigned short, C99 _Bool
     // unsigned short, void *
-    // unsigned short, char * 
+    // unsigned short, char *
 
     // unsigned long, char
     // unsigned long, int
@@ -598,7 +598,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // unsigned long, double
     // unsigned long, C99 _Bool
     // unsigned long, void *
-    // unsigned long, char * 
+    // unsigned long, char *
 
     // unsigned long long, char
     // unsigned long long, int
@@ -614,7 +614,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // unsigned long long, double
     // unsigned long long, C99 _Bool
     // unsigned long long, void *
-    // unsigned long long, char * 
+    // unsigned long long, char *
 
     // float, char
     // float, int
@@ -630,7 +630,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // float, double
     // float, C99 _Bool
     // float, void *
-    // float, char * 
+    // float, char *
 
     // double, char
     // double, int
@@ -646,7 +646,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // double, double
     // double, C99 _Bool
     // double, void *
-    // double, char * 
+    // double, char *
 
     // C99 _Bool, char
     // C99 _Bool, int
@@ -662,7 +662,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // C99 _Bool, double
     // C99 _Bool, C99 _Bool
     // C99 _Bool, void *
-    // C99 _Bool, char * 
+    // C99 _Bool, char *
 
     // void *, char
     // void *, int
@@ -678,8 +678,8 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // void *, double
     // void *, C99 _Bool
     // void *, void *
-    // void *, char * 
-    
+    // void *, char *
+
     // char *, char
     // char *, int
     // char *, short
@@ -694,37 +694,37 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     // char *, double
     // char *, C99 _Bool
     // char *, void *
-    // char *, char * 
-    
-    
-    
+    // char *, char *
+
+
+
     // literal values
     WO_TEST_EQUAL(1000, 1000);
     WO_TEST_NOT_EQUAL(2000, 4000);
-    
+
     // literal values with casts
     WO_TEST_EQUAL((float)10.0, (float)10.0);
     WO_TEST_NOT_EQUAL((float)10.0, (float)200.0);
-    
+
     // literal values with mismatched casts
     WO_TEST_EQUAL((int)100, (long)100);
     WO_TEST_NOT_EQUAL((int)100, (long)1000);
 
     // compound values (variables)
-    
-    
-    
+
+
+
     // compound values (literals)
-    
-    
-    
+
+
+
     // compound values (variables + literals)
 
 
-    
+
     // arrays
-    
-    
+
+
     // structures
     NSPoint point1  = {10.0f, 300.0f};
     NSPoint point2  = {10.0f, 300.0f};
@@ -758,53 +758,53 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(size2, point2);   // incompatible types
     WO_TEST_NOT_EQUAL(size2, range2);   // incompatible types
     WO_TEST_NOT_EQUAL(size2, rect2);    // incompatible types
-    
+
     // pointers
-    
-    
-    
-    
-    
-    
-    
-    
-    
+
+
+
+
+
+
+
+
+
     // >, <, >=, <=
     char small  = 'd';
     char big    = 'z';
     char other  = 'd';
-    
+
     WO_TEST_GREATER_THAN(big, small);
     WO_TEST_NOT_GREATER_THAN(small, big);
     WO_TEST_NOT_GREATER_THAN(small, other);
-    
+
     WO_TEST_LESS_THAN(small, big);
     WO_TEST_NOT_LESS_THAN(big, small);
     WO_TEST_NOT_LESS_THAN(small, other);
-    
+
     int negative    = -100;
     int middle      = 50;
     int positive    = 75;
     int otherMiddle = 50;
-    
+
     WO_TEST_GREATER_THAN(middle, negative);
     WO_TEST_GREATER_THAN(positive, negative);
     WO_TEST_GREATER_THAN(positive, middle);
-    
+
     WO_TEST_NOT_GREATER_THAN(middle, positive);
     WO_TEST_NOT_GREATER_THAN(negative, middle);
     WO_TEST_NOT_GREATER_THAN(negative, positive);
     WO_TEST_NOT_GREATER_THAN(middle, otherMiddle);
-        
+
     WO_TEST_LESS_THAN(negative, middle);
     WO_TEST_LESS_THAN(negative, positive);
     WO_TEST_LESS_THAN(middle, positive);
-    
+
     WO_TEST_NOT_LESS_THAN(middle, negative);
     WO_TEST_NOT_LESS_THAN(positive, middle);
     WO_TEST_NOT_LESS_THAN(positive, negative);
     WO_TEST_NOT_LESS_THAN(middle, otherMiddle);
-        
+
     // casts to signed types
     WO_TEST_GREATER_THAN((short)big, (short)small);
     WO_TEST_NOT_GREATER_THAN((short)small, (short)big);
@@ -826,7 +826,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN((short)positive, (short)middle);
     WO_TEST_NOT_LESS_THAN((short)positive, (short)negative);
     WO_TEST_NOT_LESS_THAN((short)middle, (short)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((long)big, (long)small);
     WO_TEST_NOT_GREATER_THAN((long)small, (long)big);
     WO_TEST_NOT_GREATER_THAN((long)small, (long)other);
@@ -847,7 +847,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN((long)positive, (long)middle);
     WO_TEST_NOT_LESS_THAN((long)positive, (long)negative);
     WO_TEST_NOT_LESS_THAN((long)middle, (long)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((long long)big, (long long)small);
     WO_TEST_NOT_GREATER_THAN((long long)small, (long long)big);
     WO_TEST_NOT_GREATER_THAN((long long)small, (long long)other);
@@ -868,7 +868,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN((long long)positive, (long long)middle);
     WO_TEST_NOT_LESS_THAN((long long)positive, (long long)negative);
     WO_TEST_NOT_LESS_THAN((long long)middle, (long long)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((float)big, (float)small);
     WO_TEST_NOT_GREATER_THAN((float)small, (float)big);
     WO_TEST_NOT_GREATER_THAN((float)small, (float)other);
@@ -889,7 +889,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN((float)positive, (float)middle);
     WO_TEST_NOT_LESS_THAN((float)positive, (float)negative);
     WO_TEST_NOT_LESS_THAN((float)middle, (float)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((double)big, (double)small);
     WO_TEST_NOT_GREATER_THAN((double)small, (double)big);
     WO_TEST_NOT_GREATER_THAN((double)small, (double)other);
@@ -910,7 +910,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN((double)positive, (double)middle);
     WO_TEST_NOT_LESS_THAN((double)positive, (double)negative);
     WO_TEST_NOT_LESS_THAN((double)middle, (double)otherMiddle);
-    
+
     // casts to unsigned types
     WO_TEST_GREATER_THAN((unsigned char)big, (unsigned char)small);
     WO_TEST_NOT_GREATER_THAN((unsigned char)small, (unsigned char)big);
@@ -924,7 +924,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_LESS_THAN((unsigned char)middle, (unsigned char)positive);
     WO_TEST_NOT_LESS_THAN((unsigned char)positive, (unsigned char)middle);
     WO_TEST_NOT_LESS_THAN((unsigned char)middle, (unsigned char)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((unsigned int)big, (unsigned int)small);
     WO_TEST_NOT_GREATER_THAN((unsigned int)small, (unsigned int)big);
     WO_TEST_NOT_GREATER_THAN((unsigned int)small, (unsigned int)other);
@@ -937,7 +937,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_LESS_THAN((unsigned int)middle, (unsigned int)positive);
     WO_TEST_NOT_LESS_THAN((unsigned int)positive, (unsigned int)middle);
     WO_TEST_NOT_LESS_THAN((unsigned int)middle, (unsigned int)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((unsigned long)big, (unsigned long)small);
     WO_TEST_NOT_GREATER_THAN((unsigned long)small, (unsigned long)big);
     WO_TEST_NOT_GREATER_THAN((unsigned long)small, (unsigned long)other);
@@ -950,7 +950,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_LESS_THAN((unsigned long)middle, (unsigned long)positive);
     WO_TEST_NOT_LESS_THAN((unsigned long)positive, (unsigned long)middle);
     WO_TEST_NOT_LESS_THAN((unsigned long)middle, (unsigned long)otherMiddle);
-    
+
     WO_TEST_GREATER_THAN((unsigned short)big, (unsigned short)small);
     WO_TEST_NOT_GREATER_THAN((unsigned short)small, (unsigned short)big);
     WO_TEST_NOT_GREATER_THAN((unsigned short)small, (unsigned short)other);
@@ -959,36 +959,36 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN((unsigned short)small, (unsigned short)other);
     WO_TEST_GREATER_THAN((unsigned short)positive, (unsigned short)middle);
     WO_TEST_NOT_GREATER_THAN((unsigned short)middle, (unsigned short)positive);
-    WO_TEST_NOT_GREATER_THAN ((unsigned short)middle, (unsigned short)otherMiddle); 
-    WO_TEST_LESS_THAN((unsigned short)middle, (unsigned short)positive); 
-    WO_TEST_NOT_LESS_THAN((unsigned short)positive, (unsigned short)middle); 
-    WO_TEST_NOT_LESS_THAN((unsigned short)middle, (unsigned short)otherMiddle); 
-    WO_TEST_GREATER_THAN((unsigned long long)big, (unsigned long long)small); 
-    WO_TEST_NOT_GREATER_THAN ((unsigned long long)small, (unsigned long long)big); 
+    WO_TEST_NOT_GREATER_THAN ((unsigned short)middle, (unsigned short)otherMiddle);
+    WO_TEST_LESS_THAN((unsigned short)middle, (unsigned short)positive);
+    WO_TEST_NOT_LESS_THAN((unsigned short)positive, (unsigned short)middle);
+    WO_TEST_NOT_LESS_THAN((unsigned short)middle, (unsigned short)otherMiddle);
+    WO_TEST_GREATER_THAN((unsigned long long)big, (unsigned long long)small);
+    WO_TEST_NOT_GREATER_THAN ((unsigned long long)small, (unsigned long long)big);
     WO_TEST_NOT_GREATER_THAN ((unsigned long long)small, (unsigned long long)other);
     WO_TEST_LESS_THAN((unsigned long long)small, (unsigned long long)big);
     WO_TEST_NOT_LESS_THAN((unsigned long long)big, (unsigned long long)small);
     WO_TEST_NOT_LESS_THAN((unsigned long long)small, (unsigned long long)other);
-    WO_TEST_GREATER_THAN ((unsigned long long)positive, (unsigned long long)middle); 
-    WO_TEST_NOT_GREATER_THAN ((unsigned long long)middle, (unsigned long long)positive); 
-    WO_TEST_NOT_GREATER_THAN ((unsigned long long)middle, (unsigned long long)otherMiddle); 
-    WO_TEST_LESS_THAN((unsigned long long)middle, (unsigned long long)positive); 
+    WO_TEST_GREATER_THAN ((unsigned long long)positive, (unsigned long long)middle);
+    WO_TEST_NOT_GREATER_THAN ((unsigned long long)middle, (unsigned long long)positive);
+    WO_TEST_NOT_GREATER_THAN ((unsigned long long)middle, (unsigned long long)otherMiddle);
+    WO_TEST_LESS_THAN((unsigned long long)middle, (unsigned long long)positive);
     WO_TEST_NOT_LESS_THAN ((unsigned long long)positive, (unsigned long long)middle);
     WO_TEST_NOT_LESS_THAN((unsigned long long)middle, (unsigned long long)otherMiddle);
-    
-    
-    
-    
-    
-    
-    
+
+
+
+
+
+
+
     // casts to non-matching types
-    
-    
-    
-    
-    
-    
+
+
+
+
+
+
     // objects: strings
     WO_TEST_GREATER_THAN(@"foo", @"bar");
     WO_TEST_GREATER_THAN(@"food", @"foo");
@@ -1000,39 +1000,39 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_LESS_THAN(@"foo", @"bar");
     WO_TEST_NOT_LESS_THAN(@"foo", @"foo");
     WO_TEST_NOT_LESS_THAN(@"food", @"foo");
-    
+
     // objects: numbers
     NSNumber *smallNumber   = [NSNumber numberWithInt:3];
     NSNumber *bigNumber     = [NSNumber numberWithFloat:10.0];
     NSNumber *otherNumber   = [NSNumber numberWithLongLong:10];
-    
+
     WO_TEST_GREATER_THAN(bigNumber, smallNumber);
     WO_TEST_NOT_GREATER_THAN(smallNumber, bigNumber);
     WO_TEST_NOT_GREATER_THAN(bigNumber, otherNumber);
-    
+
     WO_TEST_LESS_THAN(smallNumber, bigNumber);
     WO_TEST_NOT_LESS_THAN(bigNumber, smallNumber);
     WO_TEST_NOT_LESS_THAN(bigNumber, otherNumber);
-    
+
     // objects that don't implement compare: should raise exception
     NSFileManager *manager = [NSFileManager defaultManager];
     NSValue *managerValue = [NSValue valueWithNonretainedObject:manager];
     NSString *compareString = @"hello";
-    NSValue *stringValue = [NSValue valueWithNonretainedObject:compareString];    
+    NSValue *stringValue = [NSValue valueWithNonretainedObject:compareString];
     WO_TEST_THROWS([managerValue WOTest_compare:stringValue]);
-        
+
     // can't compare objects and non-objects
     int         scalar      = 1234;
     const void  *scalarPtr  = &scalar;
     WO_TEST_THROWS([stringValue WOTest_compare:[NSValue value:scalarPtr withObjCType:@encode(typeof(scalar))]]);
     WO_TEST_THROWS([stringValue WOTest_compare:[NSValue valueWithPoint:NSZeroPoint]]);
-    
-    
+
+
     typeof(int) dastardlyScalar = 10000;
     WO_TEST_THROWS
-        ([[NSValue valueWithBytes:&dastardlyScalar 
+        ([[NSValue valueWithBytes:&dastardlyScalar
                          objCType:@encode(int)] WOTest_testIsEqualToValue:[NSValue valueWithNonretainedObject:@"foo"]]);
-    
+
     typeof(nil) nilVar = nil;
     NSValue *nilValue = [NSValue valueWithBytes:&nilVar objCType:@encode(typeof(nil))];
     NSString *objectString = @"foo";
@@ -1040,47 +1040,47 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_TRUE([nonVoidValue WOTest_isObject]);
     WO_TEST_DOES_NOT_THROW([nonVoidValue WOTest_testIsEqualToValue:nilValue]);
     WO_TEST_DOES_NOT_THROW([nilValue WOTest_testIsEqualToValue:nonVoidValue]);
-    
+
     // can also compare pointers to void to nil
     NSValue *objectValue = [NSValue valueWithNonretainedObject:[NSString stringWithFormat:@"bar"]];
     WO_TEST_FALSE([objectValue WOTest_isObject]); // due to valueWithNonretainedObject
     WO_TEST_TRUE([objectValue WOTest_isPointerToVoid]);
     WO_TEST_DOES_NOT_THROW([objectValue WOTest_testIsEqualToValue:nilValue]);
     WO_TEST_DOES_NOT_THROW([nilValue WOTest_testIsEqualToValue:objectValue]);
-    
+
     NSValue *realObjectValue = [NSValue valueWithNonretainedObject:[[[NSObject alloc] init] autorelease]];
     WO_TEST_FALSE([realObjectValue WOTest_isObject]);
     WO_TEST_TRUE([realObjectValue WOTest_isPointerToVoid]);
     WO_TEST_DOES_NOT_THROW([realObjectValue WOTest_testIsEqualToValue:nilValue]);
     WO_TEST_DOES_NOT_THROW([nilValue WOTest_testIsEqualToValue:realObjectValue]);
-    
+
     NSValue *otherValue = [NSValue valueWithNonretainedObject:@"bar"];
     WO_TEST_FALSE([otherValue WOTest_isObject]);
     WO_TEST_TRUE([otherValue WOTest_isPointerToVoid]);
-    
+
     typeof("^v") myCoolVar = ("^v");
     NSValue *charArray = [NSValue valueWithBytes:&myCoolVar objCType:@encode(typeof("^v"))];
     WO_TEST_TRUE([charArray WOTest_isCharArray]);
     WO_TEST_EQUAL([charArray WOTest_stringValue], @"^v");
-    
+
     char *constChar = "^v";
     NSValue *constCharValue = [NSValue valueWithBytes:&constChar objCType:@encode(char*)];
     WO_TEST_TRUE([constCharValue WOTest_isCharacterString]);
     WO_TEST_EQUAL([constCharValue WOTest_stringValue], @"^v");
-    WO_TEST_EQUAL([charArray WOTest_stringValue], [constCharValue WOTest_stringValue]);    
-    
+    WO_TEST_EQUAL([charArray WOTest_stringValue], [constCharValue WOTest_stringValue]);
+
     WO_TEST_EQUAL([otherValue objCType], "^v");
-    
+
     WO_TEST_EQUAL(strcmp([nilValue objCType], @encode(typeof(nil))), 0);
     typeof(nil) otherNilVar = nil;
     NSValue *otherNilValue = [NSValue valueWithBytes:&otherNilVar objCType:@encode(typeof(nil))];
     WO_TEST_EQUAL([nilValue WOTest_compare:otherNilValue], NSOrderedSame);
     WO_TEST_NOT_EQUAL([otherValue nonretainedObjectValue], nil);
-    WO_TEST_DOES_NOT_THROW([nilValue WOTest_testIsEqualToValue:otherValue]);    
-    
+    WO_TEST_DOES_NOT_THROW([nilValue WOTest_testIsEqualToValue:otherValue]);
+
     const char *constCharArray = "my char array";
     char *nonConstCharArray = "my char array";
-    
+
     WO_TEST_EQUAL("my char array", "my char array");
     WO_TEST_EQUAL(constCharArray, nonConstCharArray);
     WO_TEST_EQUAL(nonConstCharArray, constCharArray);
@@ -1090,32 +1090,32 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_EQUAL(constCharArray, "my char array");
     WO_TEST_NOT_EQUAL("my char array", "my other char array");
     WO_TEST_NOT_EQUAL("hello", 0);
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
-    
-    
-    
+
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testNSStringCategory
 {
-    // should pass    
+    // should pass
     NSString *string1 = @"Fun\n  \nFun ";
     NSString *string2 = @"Fun Fun ";
     NSString *string3 = [string1 WOTest_stringByCollapsingWhitespace];
-    
+
     WO_TEST_EQUAL(string2, string3);
     WO_TEST_EQUAL(string3, string2);
-    
+
     NSString *string4 = @"\n\r Not fun at all...";
     NSString *string5 = @" Not fun at all...";
     NSString *string6 = [string4 WOTest_stringByCollapsingWhitespace];
-    
+
     WO_TEST_EQUAL(string5, string6);
     WO_TEST_EQUAL(string6, string5);
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
@@ -1123,57 +1123,57 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_NOT_EQUAL(string3, string2);
     WO_TEST_NOT_EQUAL(string5, string6);
     WO_TEST_NOT_EQUAL(string6, string5);
-    
-    [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default    
+
+    [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testNSExceptionCategory
 {
-    NSException *exception1 = 
+    NSException *exception1 =
     [NSException exceptionWithName:@"foo" reason:@"bar" userInfo:nil];
     WO_TEST_EQUAL([NSException WOTest_descriptionForException:exception1], @"foo: bar");
-    
+
     // NSImage responds to name but not reason
     NSImage *exception2 = [[[NSImage alloc] initWithSize:NSZeroSize] autorelease];
     [exception2 setName:@"Roger Smith"];
     WO_TEST_EQUAL([NSException WOTest_descriptionForException:exception2],
                   ([NSString stringWithFormat:@"%@ (%x)", [exception2 name], exception2]));
-    
+
     // NSObject responds to description but not to name or reason
     NSObject *exception3 = [[[NSObject alloc] init] autorelease];
     WO_TEST_EQUAL([NSException WOTest_descriptionForException:exception3], [exception3 description]);
+
     WO_TEST_EQUAL([NSException WOTest_nameForException:nil], @"no exception");
     WO_TEST_EQUAL([NSException WOTest_nameForException:@"hello"], @"hello");
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
-    
+
     WO_TEST_EQUAL([NSException WOTest_descriptionForException:exception1], @"welcome");
     WO_TEST_NOT_EQUAL([NSException WOTest_descriptionForException:exception1], @"foo: bar");
-    
+
     WO_TEST_NOT_EQUAL([NSException WOTest_nameForException:nil], @"no exception");
     WO_TEST_NOT_EQUAL([NSException WOTest_nameForException:@"hello"], @"hello");
-    
-    [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default    
+
+    [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testPointerToVoidTests
 {
     // should pass
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testIntTests
 {
     // should pass
-    
+
     WO_TEST_IS_INT((int)-2000);
     WO_TEST_IS_INT((int)-1000);
     WO_TEST_IS_INT((int)-10);
@@ -1193,7 +1193,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_IS_NOT_INT((unsigned)1000);
     WO_TEST_IS_NOT_INT((float)50000.0);
     WO_TEST_IS_NOT_INT((double)1350000.0);
-    
+
     WO_TEST_INT_POSITIVE((int)1);
     WO_TEST_INT_POSITIVE((int)2);
     WO_TEST_INT_POSITIVE((int)5);
@@ -1202,7 +1202,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_POSITIVE((int)1000);
     WO_TEST_INT_POSITIVE((int)50000);
     WO_TEST_INT_POSITIVE((int)1350000);
-    
+
     WO_TEST_INT_NEGATIVE((int)-1);
     WO_TEST_INT_NEGATIVE((int)-2);
     WO_TEST_INT_NEGATIVE((int)-5);
@@ -1211,9 +1211,9 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NEGATIVE((int)-1000);
     WO_TEST_INT_NEGATIVE((int)-50000);
     WO_TEST_INT_NEGATIVE((int)-1350000);
-    
+
     WO_TEST_INT_ZERO((int)0);
-    
+
     WO_TEST_INT_NOT_ZERO((int)1);
     WO_TEST_INT_NOT_ZERO((int)2);
     WO_TEST_INT_NOT_ZERO((int)200);
@@ -1222,7 +1222,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NOT_ZERO((int)-2);
     WO_TEST_INT_NOT_ZERO((int)-200);
     WO_TEST_INT_NOT_ZERO((int)-50000);
-    
+
     WO_TEST_INTS_EQUAL((int)0, (int)0);
     WO_TEST_INTS_EQUAL((int)2, (int)2);
     WO_TEST_INTS_EQUAL((int)20, (int)20);
@@ -1231,7 +1231,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INTS_EQUAL((int)-100, (int)-100);
     WO_TEST_INTS_EQUAL((int)-200, (int)-200);
     WO_TEST_INTS_EQUAL((int)-1350000, (int)-1350000);
-    
+
     WO_TEST_INTS_NOT_EQUAL((int)1, (int)2);
     WO_TEST_INTS_NOT_EQUAL((int)2, (int)1);
     WO_TEST_INTS_NOT_EQUAL((int)10, (int)20);
@@ -1240,7 +1240,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INTS_NOT_EQUAL((int)0, (int)-1);
     WO_TEST_INTS_NOT_EQUAL((int)-10, (int)10);
     WO_TEST_INTS_NOT_EQUAL((int)-100, (int)-200);
-    
+
     WO_TEST_INT_GREATER_THAN((int)1, (int)0);
     WO_TEST_INT_GREATER_THAN((int)10, (int)5);
     WO_TEST_INT_GREATER_THAN((int)0, (int)-5);
@@ -1249,7 +1249,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_GREATER_THAN((int)1000, (int)999);
     WO_TEST_INT_GREATER_THAN((int)1350000, (int)5000);
     WO_TEST_INT_GREATER_THAN((int)5000000, (int)-5000000);
-        
+
     WO_TEST_INT_NOT_GREATER_THAN((int)1, (int)1);
     WO_TEST_INT_NOT_GREATER_THAN((int)1, (int)2);
     WO_TEST_INT_NOT_GREATER_THAN((int)0, (int)1);
@@ -1258,7 +1258,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NOT_GREATER_THAN((int)-500, (int)-400);
     WO_TEST_INT_NOT_GREATER_THAN((int)-1600, (int)-1599);
     WO_TEST_INT_NOT_GREATER_THAN((int)400, (int)400);
-    
+
     WO_TEST_INT_LESS_THAN((int)0, (int)1);
     WO_TEST_INT_LESS_THAN((int)1, (int)2);
     WO_TEST_INT_LESS_THAN((int)-1, (int)0);
@@ -1267,7 +1267,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_LESS_THAN((int)1000, (int)1001);
     WO_TEST_INT_LESS_THAN((int)1350, (int)1000000);
     WO_TEST_INT_LESS_THAN((int)-5000000, (int)1);
-    
+
     WO_TEST_INT_NOT_LESS_THAN((int)0, (int)0);
     WO_TEST_INT_NOT_LESS_THAN((int)1, (int)0);
     WO_TEST_INT_NOT_LESS_THAN((int)2, (int)1);
@@ -1276,7 +1276,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NOT_LESS_THAN((int)2000, (int)1000);
     WO_TEST_INT_NOT_LESS_THAN((int)5000, (int)5000);
     WO_TEST_INT_NOT_LESS_THAN((int)-10000, (int)-12000);
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
@@ -1289,7 +1289,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_IS_INT((unsigned)1000);
     WO_TEST_IS_INT((unsigned)50000);
     WO_TEST_IS_INT((unsigned)1350000);
-    
+
     WO_TEST_IS_NOT_INT((int)-2000);
     WO_TEST_IS_NOT_INT((int)-1000);
     WO_TEST_IS_NOT_INT((int)-10);
@@ -1299,7 +1299,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_IS_NOT_INT((int)1000);
     WO_TEST_IS_NOT_INT((int)50000);
     WO_TEST_IS_NOT_INT((int)1350000);
-    
+
     WO_TEST_INT_POSITIVE((int)0);
     WO_TEST_INT_POSITIVE((int)-2);
     WO_TEST_INT_POSITIVE((int)-5);
@@ -1308,7 +1308,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_POSITIVE((int)-1000);
     WO_TEST_INT_POSITIVE((int)-50000);
     WO_TEST_INT_POSITIVE((int)-1350000);
-    
+
     WO_TEST_INT_NEGATIVE((int)0);
     WO_TEST_INT_NEGATIVE((int)2);
     WO_TEST_INT_NEGATIVE((int)5);
@@ -1317,7 +1317,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NEGATIVE((int)1000);
     WO_TEST_INT_NEGATIVE((int)50000);
     WO_TEST_INT_NEGATIVE((int)1350000);
-    
+
     WO_TEST_INT_ZERO((int)1);
     WO_TEST_INT_ZERO((int)2);
     WO_TEST_INT_ZERO((int)200);
@@ -1326,9 +1326,9 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_ZERO((int)-2);
     WO_TEST_INT_ZERO((int)-200);
     WO_TEST_INT_ZERO((int)-50000);
-    
+
     WO_TEST_INT_NOT_ZERO((int)0);
-    
+
     WO_TEST_INTS_EQUAL((int)0, (int)10);
     WO_TEST_INTS_EQUAL((int)2, (int)1);
     WO_TEST_INTS_EQUAL((int)20, (int)-20);
@@ -1355,7 +1355,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_GREATER_THAN((int)999, (int)1000);
     WO_TEST_INT_GREATER_THAN((int)1350000, (int)5000000);
     WO_TEST_INT_GREATER_THAN((int)-5000000, (int)5000000);
-        
+
     WO_TEST_INT_NOT_GREATER_THAN((int)1, (int)0);
     WO_TEST_INT_NOT_GREATER_THAN((int)2, (int)1);
     WO_TEST_INT_NOT_GREATER_THAN((int)1, (int)-10);
@@ -1364,7 +1364,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NOT_GREATER_THAN((int)-400, (int)-500);
     WO_TEST_INT_NOT_GREATER_THAN((int)-1599, (int)-1600);
     WO_TEST_INT_NOT_GREATER_THAN((int)400, (int)1);
-    
+
     WO_TEST_INT_LESS_THAN((int)1, (int)0);
     WO_TEST_INT_LESS_THAN((int)2, (int)1);
     WO_TEST_INT_LESS_THAN((int)0, (int)-1);
@@ -1373,7 +1373,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_LESS_THAN((int)1001, (int)1000);
     WO_TEST_INT_LESS_THAN((int)1000000, (int)1350);
     WO_TEST_INT_LESS_THAN((int)1, (int)-5000000);
-    
+
     WO_TEST_INT_NOT_LESS_THAN((int)0, (int)1);
     WO_TEST_INT_NOT_LESS_THAN((int)1, (int)2);
     WO_TEST_INT_NOT_LESS_THAN((int)2, (int)3);
@@ -1382,16 +1382,16 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_INT_NOT_LESS_THAN((int)1000, (int)2000);
     WO_TEST_INT_NOT_LESS_THAN((int)2000, (int)5000);
     WO_TEST_INT_NOT_LESS_THAN((int)-16000, (int)-12000);
-    
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testUnsignedTests
 {
     // should pass
-        
+
     WO_TEST_UNSIGNED_ZERO((unsigned)0);
-    
+
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)1);
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)2);
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)200);
@@ -1400,7 +1400,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)65200);
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)100000);
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)5000000);
-    
+
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)0, (unsigned)0);
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)2, (unsigned)2);
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)20, (unsigned)20);
@@ -1409,7 +1409,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)23000, (unsigned)23000);
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)165200, (unsigned)165200);
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)1350000, (unsigned)1350000);
-    
+
     WO_TEST_UNSIGNEDS_NOT_EQUAL((unsigned)1, (unsigned)2);
     WO_TEST_UNSIGNEDS_NOT_EQUAL((unsigned)2, (unsigned)1);
     WO_TEST_UNSIGNEDS_NOT_EQUAL((unsigned)10, (unsigned)20);
@@ -1418,7 +1418,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNEDS_NOT_EQUAL((unsigned)0, (unsigned)1);
     WO_TEST_UNSIGNEDS_NOT_EQUAL((unsigned)10, (unsigned)1230);
     WO_TEST_UNSIGNEDS_NOT_EQUAL((unsigned)100, (unsigned)200);
-    
+
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)1, (unsigned)0);
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)10, (unsigned)5);
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)6, (unsigned)5);
@@ -1427,7 +1427,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)1000, (unsigned)999);
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)1350000, (unsigned)5000);
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)5000000, (unsigned)50);
-        
+
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)1, (unsigned)1);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)1, (unsigned)2);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)0, (unsigned)1);
@@ -1436,7 +1436,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)500, (unsigned)4500);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)1599, (unsigned)1600);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)400, (unsigned)400);
-    
+
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)0, (unsigned)1);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1, (unsigned)2);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1, (unsigned)1200);
@@ -1445,7 +1445,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1000, (unsigned)1001);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1350, (unsigned)1000000);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)5000000, (unsigned)10000000);
-    
+
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)0, (unsigned)0);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)1, (unsigned)0);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)2, (unsigned)1);
@@ -1454,10 +1454,10 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)2000, (unsigned)1000);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)5000, (unsigned)5000);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)12000, (unsigned)10000);
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
-    
+
     WO_TEST_UNSIGNED_ZERO((unsigned)1);
     WO_TEST_UNSIGNED_ZERO((unsigned)2);
     WO_TEST_UNSIGNED_ZERO((unsigned)200);
@@ -1466,9 +1466,9 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_ZERO((unsigned)20);
     WO_TEST_UNSIGNED_ZERO((unsigned)2000);
     WO_TEST_UNSIGNED_ZERO((unsigned)500000);
-    
+
     WO_TEST_UNSIGNED_NOT_ZERO((unsigned)0);
-    
+
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)0, (unsigned)10);
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)2, (unsigned)1);
     WO_TEST_UNSIGNEDS_EQUAL((unsigned)20, (unsigned)21);
@@ -1495,7 +1495,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)999, (unsigned)1000);
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)1350000, (unsigned)5000000);
     WO_TEST_UNSIGNED_GREATER_THAN((unsigned)5000000, (unsigned)5000000);
-        
+
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)1, (unsigned)0);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)2, (unsigned)1);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)11, (unsigned)10);
@@ -1504,7 +1504,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)600, (unsigned)599);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)1600, (unsigned)1599);
     WO_TEST_UNSIGNED_NOT_GREATER_THAN((unsigned)400, (unsigned)1);
-    
+
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1, (unsigned)0);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)2, (unsigned)1);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)0, (unsigned)0);
@@ -1513,7 +1513,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1001, (unsigned)1000);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)1000000, (unsigned)1350);
     WO_TEST_UNSIGNED_LESS_THAN((unsigned)12, (unsigned)4);
-    
+
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)0, (unsigned)1);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)1, (unsigned)2);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)2, (unsigned)3);
@@ -1522,14 +1522,14 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)1000, (unsigned)2000);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)2000, (unsigned)5000);
     WO_TEST_UNSIGNED_NOT_LESS_THAN((unsigned)16000, (unsigned)18000);
-    
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testFloatTests
 {
     // should pass
-    
+
     WO_TEST_FLOAT_POSITIVE((float)1);
     WO_TEST_FLOAT_POSITIVE((float)2);
     WO_TEST_FLOAT_POSITIVE((float)5);
@@ -1538,7 +1538,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_POSITIVE((float)1000);
     WO_TEST_FLOAT_POSITIVE((float)50000);
     WO_TEST_FLOAT_POSITIVE((float)1350000);
-    
+
     WO_TEST_FLOAT_NEGATIVE((float)-1);
     WO_TEST_FLOAT_NEGATIVE((float)-2);
     WO_TEST_FLOAT_NEGATIVE((float)-5);
@@ -1547,9 +1547,9 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_NEGATIVE((float)-1000);
     WO_TEST_FLOAT_NEGATIVE((float)-50000);
     WO_TEST_FLOAT_NEGATIVE((float)-1350000);
-    
+
     WO_TEST_FLOAT_ZERO((float)0);
-    
+
     WO_TEST_FLOAT_NOT_ZERO((float)1);
     WO_TEST_FLOAT_NOT_ZERO((float)2);
     WO_TEST_FLOAT_NOT_ZERO((float)200);
@@ -1558,7 +1558,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_NOT_ZERO((float)-2);
     WO_TEST_FLOAT_NOT_ZERO((float)-200);
     WO_TEST_FLOAT_NOT_ZERO((float)-50000);
-    
+
     WO_TEST_FLOATS_EQUAL((float)0, 0);
     WO_TEST_FLOATS_EQUAL((float)2, 2);
     WO_TEST_FLOATS_EQUAL((float)20, 20);
@@ -1567,7 +1567,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOATS_EQUAL((float)-100, -100);
     WO_TEST_FLOATS_EQUAL((float)-200, -200);
     WO_TEST_FLOATS_EQUAL((float)-1350000, -1350000);
-    
+
     WO_TEST_FLOATS_NOT_EQUAL((float)1, 2);
     WO_TEST_FLOATS_NOT_EQUAL((float)2, 1);
     WO_TEST_FLOATS_NOT_EQUAL((float)10, 20);
@@ -1576,7 +1576,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOATS_NOT_EQUAL((float)0, -1);
     WO_TEST_FLOATS_NOT_EQUAL((float)-10, 10);
     WO_TEST_FLOATS_NOT_EQUAL((float)-100, -200);
-    
+
     WO_TEST_FLOAT_GREATER_THAN((float)1, 0);
     WO_TEST_FLOAT_GREATER_THAN((float)10, 5);
     WO_TEST_FLOAT_GREATER_THAN((float)0, -5);
@@ -1585,7 +1585,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_GREATER_THAN((float)1000, 999);
     WO_TEST_FLOAT_GREATER_THAN((float)1350000, 5000);
     WO_TEST_FLOAT_GREATER_THAN((float)5000000, -5000000);
-    
+
     WO_TEST_FLOAT_NOT_GREATER_THAN((float)1, 1);
     WO_TEST_FLOAT_NOT_GREATER_THAN((float)1, 2);
     WO_TEST_FLOAT_NOT_GREATER_THAN((float)0, 1);
@@ -1594,7 +1594,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_NOT_GREATER_THAN((float)-500, -400);
     WO_TEST_FLOAT_NOT_GREATER_THAN((float)-1600, -1599);
     WO_TEST_FLOAT_NOT_GREATER_THAN((float)400, 400);
-    
+
     WO_TEST_FLOAT_LESS_THAN((float)0, 1);
     WO_TEST_FLOAT_LESS_THAN((float)1, 2);
     WO_TEST_FLOAT_LESS_THAN((float)-1, 0);
@@ -1603,7 +1603,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_LESS_THAN((float)1000, 1001);
     WO_TEST_FLOAT_LESS_THAN((float)1350, 1000000);
     WO_TEST_FLOAT_LESS_THAN((float)-5000000, 1);
-    
+
     WO_TEST_FLOAT_NOT_LESS_THAN((float)0, 0);
     WO_TEST_FLOAT_NOT_LESS_THAN((float)1, 0);
     WO_TEST_FLOAT_NOT_LESS_THAN((float)2, 1);
@@ -1611,49 +1611,49 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_FLOAT_NOT_LESS_THAN((float)-1, -2);
     WO_TEST_FLOAT_NOT_LESS_THAN((float)2000, 1000);
     WO_TEST_FLOAT_NOT_LESS_THAN((float)5000, 5000);
-    WO_TEST_FLOAT_NOT_LESS_THAN((float)-10000, -12000);    
-    
+    WO_TEST_FLOAT_NOT_LESS_THAN((float)-10000, -12000);
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testFloatWithErrorMarginTests
 {
     // should pass
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testDoubleTests
 {
     // should pass
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testDoubleWithErrorMarginTests
 {
     // should pass
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
@@ -1661,107 +1661,107 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 {
     // should pass
 
-    
+
     // should freak out if object does not conform to NSObject protocol
 
-    
-    
+
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testStringTests
 {
     // should pass
-        
+
 
     // should freak out if object does not conform to NSObject protocol
-    
+
     // should throw an exception when passed an object that is not a subclass of NSString
-    
+
     // specifically should throw an WO_TEST_CLASS_MISMATCH_EXCEPTION
-    
+
     // should handle nil string1
-    
+
     // should handle nil string2
-    
+
     // should handle nil string1 and nil string2
-    
+
     // should handle empty string1
-    
+
     // should handle empty string2
-    
+
     // should handle empty string1 and empty string2
 
     // shorthand macros should work
-    
-    
+
+
     // in the case of prefix, suffix and contains tests should die if passed nil "expected" parameter
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testArrayTests
 {
     // should pass
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testDictionaryTests
 {
     // should pass
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
-    
-    
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testShorthandMacros
 {
     // make sure that the shorthand and longhand test macros are equivalent
-    
+
     // should pass
     WO_TEST_TRUE(YES);
     WO_TEST(YES);
-    
+
     WO_TEST_EQUAL(100, 100);
     WO_TEST_EQ(100, 100);
-    
+
     WO_TEST_NOT_EQUAL(100, 101);
     WO_TEST_NE(100, 101);
-    
+
     WO_TEST_GREATER_THAN(200, 100);
     WO_TEST_GT(200, 100);
-    
+
     WO_TEST_NOT_GREATER_THAN(100, 200);
     WO_TEST_LTE(100, 200);
     WO_TEST_NGT(100, 200);
-        
+
     WO_TEST_NOT_GREATER_THAN(100, 100);
     WO_TEST_LTE(100, 100);
     WO_TEST_NGT(100, 100);
-        
+
     WO_TEST_LESS_THAN(100, 200);
     WO_TEST_LT(100, 200);
-    
+
     WO_TEST_NOT_LESS_THAN(200, 100);
     WO_TEST_GTE(200, 100);
     WO_TEST_NLT(200, 100);
@@ -1772,31 +1772,31 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
-    
+
     WO_TEST_TRUE(NO);
     WO_TEST(NO);
-    
+
     WO_TEST_EQUAL(100, 200);
     WO_TEST_EQ(100, 200);
-    
+
     WO_TEST_NOT_EQUAL(100, 100);
     WO_TEST_NE(100, 100);
-    
+
     WO_TEST_GREATER_THAN(100, 200);
     WO_TEST_GT(100, 200);
-    
+
     WO_TEST_NOT_GREATER_THAN(200, 100);
     WO_TEST_LTE(200, 100);
     WO_TEST_NGT(200, 100);
-        
+
     WO_TEST_LESS_THAN(200, 100);
     WO_TEST_LT(200, 100);
-    
+
     WO_TEST_NOT_LESS_THAN(100, 200);
     WO_TEST_GTE(100, 200);
     WO_TEST_NLT(100, 200);
-        
-    [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default    
+
+    [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testExceptionTests
@@ -1806,26 +1806,26 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_THROWS([self raiseException]);
     WO_TEST_THROWS([self throwWOEnigmaException]);
     WO_TEST_THROWS([self throwString]);
-    
-       // BUG: busted on Leopard
-       //WO_TEST_THROWS([self throwWORootClassObject]);
+
+    // BUG: busted on Leopard
+    //WO_TEST_THROWS([self throwWORootClassObject]);
     WO_TEST_THROWS([self throwObject]);
     WO_TEST_THROWS([self makeCocoaThrowException]);
     WO_TEST_THROWS([self makeCocoaThrowNSRangeException]);
-    
+
     WO_TEST_DOES_NOT_THROW([self doNotThrowException]);
-    
+
     WO_TEST_THROWS_EXCEPTION_NAMED
         ([self throwWOEnigmaException], @"WOEnigmaException");
     WO_TEST_THROWS_EXCEPTION_NAMED([self throwString], @"party");
-    
+
     WO_TEST_DOES_NOT_THROW_EXCEPTION_NAMED([self doNotThrowException], @"Roy");
     WO_TEST_DOES_NOT_THROW_EXCEPTION_NAMED([self throwException], @"Other");
 
-       // BUG: busted on Leopard
+    // BUG: busted on Leopard
     //WO_TEST_DOES_NOT_THROW_EXCEPTION_NAMED([self throwWORootClassObject], @"x");
     //WO_TEST_THROWS_EXCEPTION_NAMED([self throwWORootClassObject], @"WORootClass");
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
 
@@ -1833,34 +1833,34 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_DOES_NOT_THROW([self raiseException]);
     WO_TEST_DOES_NOT_THROW([self throwWOEnigmaException]);
     WO_TEST_DOES_NOT_THROW([self throwString]);
-    
-       // BUG: Busted on Leopard
-       //WO_TEST_DOES_NOT_THROW([self throwWORootClassObject]);
+
+    // BUG: Busted on Leopard
+    //WO_TEST_DOES_NOT_THROW([self throwWORootClassObject]);
     WO_TEST_DOES_NOT_THROW([self throwObject]);
     WO_TEST_DOES_NOT_THROW([self makeCocoaThrowException]);
     WO_TEST_DOES_NOT_THROW([self makeCocoaThrowNSRangeException]);
-    
+
     WO_TEST_THROWS([self doNotThrowException]);
-    
+
     WO_TEST_DOES_NOT_THROW_EXCEPTION_NAMED
         ([self throwWOEnigmaException], @"WOEnigmaException");
     WO_TEST_DOES_NOT_THROW_EXCEPTION_NAMED([self throwString], @"party");
-    
+
     WO_TEST_THROWS_EXCEPTION_NAMED([self doNotThrowException], @"Roy");
     WO_TEST_THROWS_EXCEPTION_NAMED([self throwException], @"Other");
-    
-       // BUG: busted on Leopard
+
+    // BUG: busted on Leopard
     //WO_TEST_THROWS_EXCEPTION_NAMED([self throwWORootClassObject], @"x");
     //WO_TEST_DOES_NOT_THROW_EXCEPTION_NAMED([self throwWORootClassObject], @"WORootClass");
-    
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO]; // restore to default
 }
 
 - (void)testLowLevelExceptionTests
 {
-       // BUG: this stuff busted on Leopard
-       return;
-       
+    // BUG: this stuff busted on Leopard
+    return;
+
     [WO_TEST_SHARED_INSTANCE setExpectLowLevelExceptions:YES];  // will be reset to NO in preflight prior to next method
     WO_TEST_PASS;                                               // force update of "lastKnownLocation"
     id *object = NULL;                                          // cause a crash, but WOTest should keep running
@@ -1923,7 +1923,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
 {
     // should pass
     WO_TEST_PASS;
-    
+
     WO_TEST_IS_INT([WO_TEST_SHARED_INSTANCE anInt]);
     WO_TEST_IS_INT([WO_TEST_SHARED_INSTANCE aPositiveInt]);
     WO_TEST_IS_INT([WO_TEST_SHARED_INSTANCE aNegativeInt]);
@@ -1934,12 +1934,12 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_IS_INT([WO_TEST_SHARED_INSTANCE aSmallInt]);
     WO_TEST_IS_INT([WO_TEST_SHARED_INSTANCE aSmallPositiveInt]);
     WO_TEST_IS_INT([WO_TEST_SHARED_INSTANCE aSmallNegativeInt]);
-    
+
     WO_TEST_IS_UNSIGNED([WO_TEST_SHARED_INSTANCE anUnsigned]);
     WO_TEST_IS_UNSIGNED([WO_TEST_SHARED_INSTANCE aZeroUnsigned]);
     WO_TEST_IS_UNSIGNED([WO_TEST_SHARED_INSTANCE aBigUnsigned]);
     WO_TEST_IS_UNSIGNED([WO_TEST_SHARED_INSTANCE aSmallUnsigned]);
-    
+
     WO_TEST_IS_FLOAT([WO_TEST_SHARED_INSTANCE aFloat]);
     WO_TEST_IS_FLOAT([WO_TEST_SHARED_INSTANCE aPositiveFloat]);
     WO_TEST_IS_FLOAT([WO_TEST_SHARED_INSTANCE aNegativeFloat]);
@@ -1950,7 +1950,7 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_IS_FLOAT([WO_TEST_SHARED_INSTANCE aSmallFloat]);
     WO_TEST_IS_FLOAT([WO_TEST_SHARED_INSTANCE aSmallPositiveFloat]);
     WO_TEST_IS_FLOAT([WO_TEST_SHARED_INSTANCE aSmallNegativeFloat]);
-    
+
     WO_TEST_IS_DOUBLE([WO_TEST_SHARED_INSTANCE aDouble]);
     WO_TEST_IS_DOUBLE([WO_TEST_SHARED_INSTANCE aPositiveDouble]);
     WO_TEST_IS_DOUBLE([WO_TEST_SHARED_INSTANCE aNegativeDouble]);
@@ -1961,82 +1961,82 @@ NSMutableArray *WOEmptyInstanceMethodInvocations;
     WO_TEST_IS_DOUBLE([WO_TEST_SHARED_INSTANCE aSmallDouble]);
     WO_TEST_IS_DOUBLE([WO_TEST_SHARED_INSTANCE aSmallPositiveDouble]);
     WO_TEST_IS_DOUBLE([WO_TEST_SHARED_INSTANCE aSmallNegativeDouble]);
-    
+
     WO_TEST_INT_POSITIVE([WO_TEST_SHARED_INSTANCE aPositiveInt]);
     WO_TEST_INT_NEGATIVE([WO_TEST_SHARED_INSTANCE aNegativeInt]);
     WO_TEST_INT_ZERO([WO_TEST_SHARED_INSTANCE aZeroInt]);
-    
-    WO_TEST_INT_NOT_LESS_THAN(abs([WO_TEST_SHARED_INSTANCE aBigInt]),  
+
+    WO_TEST_INT_NOT_LESS_THAN(abs([WO_TEST_SHARED_INSTANCE aBigInt]),
                               (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_INT_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aBigPositiveInt],
                               (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_INT_NOT_GREATER_THAN([WO_TEST_SHARED_INSTANCE aBigNegativeInt],
                                  (-WO_BIG_TEST_VALUE + WO_RANDOMIZATION_RANGE));
-    
+
     WO_TEST_INT_NOT_LESS_THAN(abs([WO_TEST_SHARED_INSTANCE aSmallInt]),
                               (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_INT_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aSmallPositiveInt],
                               (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_INT_NOT_GREATER_THAN([WO_TEST_SHARED_INSTANCE aSmallNegativeInt],
                                  (-WO_SMALL_TEST_VALUE + WO_RANDOMIZATION_RANGE));
-    
+
     WO_TEST_UNSIGNED_ZERO([WO_TEST_SHARED_INSTANCE aZeroUnsigned]);
-    
+
     WO_TEST_UNSIGNED_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aBigUnsigned],
                                    (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
-    
+
     WO_TEST_UNSIGNED_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aSmallUnsigned],
-                                   (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));    
-    
+                                   (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
+
     WO_TEST_FLOAT_POSITIVE([WO_TEST_SHARED_INSTANCE aPositiveFloat]);
     WO_TEST_FLOAT_NEGATIVE([WO_TEST_SHARED_INSTANCE aNegativeFloat]);
     WO_TEST_FLOAT_ZERO([WO_TEST_SHARED_INSTANCE aZeroFloat]);
-    
-    WO_TEST_FLOAT_NOT_LESS_THAN(fabsf([WO_TEST_SHARED_INSTANCE aBigFloat]),  
+
+    WO_TEST_FLOAT_NOT_LESS_THAN(fabsf([WO_TEST_SHARED_INSTANCE aBigFloat]),
                                 (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_FLOAT_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aBigPositiveFloat],
                                 (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_FLOAT_NOT_GREATER_THAN([WO_TEST_SHARED_INSTANCE aBigNegativeFloat],
                                    (-WO_BIG_TEST_VALUE + WO_RANDOMIZATION_RANGE));
-    
+
     WO_TEST_FLOAT_NOT_LESS_THAN(fabsf([WO_TEST_SHARED_INSTANCE aSmallFloat]),
                                 (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_FLOAT_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aSmallPositiveFloat],
                                 (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_FLOAT_NOT_GREATER_THAN([WO_TEST_SHARED_INSTANCE aSmallNegativeFloat],
                                    (-WO_SMALL_TEST_VALUE + WO_RANDOMIZATION_RANGE));
-    
+
     WO_TEST_DOUBLE_POSITIVE([WO_TEST_SHARED_INSTANCE aPositiveDouble]);
     WO_TEST_DOUBLE_NEGATIVE([WO_TEST_SHARED_INSTANCE aNegativeDouble]);
     WO_TEST_DOUBLE_ZERO([WO_TEST_SHARED_INSTANCE aZeroDouble]);
-    
-    WO_TEST_DOUBLE_NOT_LESS_THAN(fabs([WO_TEST_SHARED_INSTANCE aBigDouble]),  
+
+    WO_TEST_DOUBLE_NOT_LESS_THAN(fabs([WO_TEST_SHARED_INSTANCE aBigDouble]),
                                  (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_DOUBLE_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aBigPositiveDouble],
                                  (WO_BIG_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_DOUBLE_NOT_GREATER_THAN([WO_TEST_SHARED_INSTANCE aBigNegativeDouble],
                                     (-WO_BIG_TEST_VALUE + WO_RANDOMIZATION_RANGE));
-    
+
     WO_TEST_DOUBLE_NOT_LESS_THAN(fabs([WO_TEST_SHARED_INSTANCE aSmallDouble]),
                                  (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_DOUBLE_NOT_LESS_THAN([WO_TEST_SHARED_INSTANCE aSmallPositiveDouble],
                                  (WO_SMALL_TEST_VALUE - WO_RANDOMIZATION_RANGE));
     WO_TEST_DOUBLE_NOT_GREATER_THAN([WO_TEST_SHARED_INSTANCE aSmallNegativeDouble],
                                     (-WO_SMALL_TEST_VALUE + WO_RANDOMIZATION_RANGE));
-    
+
     // should fail
     [WO_TEST_SHARED_INSTANCE setExpectFailures:YES];
-    
-
-    
-    
-    
-    
-    
-    
-    
-    
-    
+
+
+
+
+
+
+
+
+
+
+
     [WO_TEST_SHARED_INSTANCE setExpectFailures:NO];
 }
 
index ba6628b841562eba9b257190b7aef093a6f70b42..c11284c45656353dd1c5ca0a487c1fcd34945f09 100644 (file)
@@ -34,9 +34,9 @@
 - (id)initWithClass:(Class)aClass
 {
     NSParameterAssert(aClass != NULL);
-    NSParameterAssert([NSObject WOTest_isRegisteredClass:aClass]);     // only registered classes pass (do not pass meta classes)
+    NSParameterAssert([NSObject WOTest_isRegisteredClass:aClass]);  // only registered classes pass (do not pass meta classes)
     if ((self = [super initWithClass:aClass]))
-        [self setMockedClass:object_getClass(aClass)];                         // look up the meta class and use that
+        [self setMockedClass:object_getClass(aClass)];              // look up the meta class and use that
     return self;
 }
 
index 2b5974f0acc275136aa6ef2e3e7e0819125a2a27..6f8a0ea7a5edec0f0eac8f5e25ac3ba192896aed 100644 (file)
@@ -34,8 +34,8 @@
 
 + (id)newLightweightRoot
 {
-       Class class = object_getClass(self);
-       return class_createInstance(class, 0);
+    Class class = object_getClass(self);
+    return class_createInstance(class, 0);
 }
 
 - (void)dealloc
index eb2b5e926a40ddc6db6235ac0000dda11923a701..de270c862d4b92ad3033371d68878f48b81bc1ba 100644 (file)
--- a/WOMock.h
+++ b/WOMock.h
@@ -21,9 +21,9 @@
 
 #import <Foundation/Foundation.h>
 
-/*! 
+/*!
 
-There are a small number of methods defined in the WOMock class that you can use to create a mock object and then tell it how to behave. The accept, acceptOnce, reject, expect, expectOnce methods tell the mock object which selectors to accept, reject and expect. 
+There are a small number of methods defined in the WOMock class that you can use to create a mock object and then tell it how to behave. The accept, acceptOnce, reject, expect, expectOnce methods tell the mock object which selectors to accept, reject and expect.
 
 Each of these methods returns an object of type id which allows you to chain selectors together using the standard Objective-C pattern:
 
@@ -38,24 +38,24 @@ The mocked class must at least implement the NSObject method, instanceMethodSign
 
     /*! Selectors that should be accepted. */
     NSMutableSet            *accepted;
-    
+
     /*! Selectors that should be accepted once only. */
     NSMutableSet            *acceptedOnce;
-    
+
     /*! Selectors that should be expected. */
     NSMutableSet            *expected;
-    
+
     /*! Selectors that should be expected once only. */
     NSMutableSet            *expectedOnce;
-    
+
     /*! Selectors that should be expected in a specific order. */
     NSMutableArray          *expectedInOrder;
 
     /*! Selectors that should be rejected. */
-    NSMutableSet            *rejected; 
-    
+    NSMutableSet            *rejected;
+
     NSMutableDictionary     *methodSignatures;
-    
+
     BOOL                    acceptsByDefault;
 }
 
@@ -92,7 +92,7 @@ The mocked class must at least implement the NSObject method, instanceMethodSign
  These are recording methods used for setting up expectations about which selectors should be rejected, accepted, accepted once, expected, expected once, or expected in order.
 
  When the mock receives a message it checks its internal lists in the following order (in order of decreasing specificity):
+
  -# rejected
  -# expected in order
  -# expected once
@@ -101,18 +101,18 @@ The mocked class must at least implement the NSObject method, instanceMethodSign
  -# accepted
 
  Rejected selectors cause an exception to be raised.
+
  By default, if a selector does not appear in any of the internal lists an exception is raised. This latter behaviour requires you to be explicit about <em>all</em> selectors which a mock object may receive. For example, you may have a mock object that stands in for an NSString instance and expect that it be sent a "lowercaseString" selector. If during your test you also send an "uppercaseString" selector then an exception will be raised (because the selector does not appear in the internal lists, even though it is a valid NSString selector). A small number of methods will be accepted even without being explicitly added the the lists; these include methods like retain and release and other NSObject protocol methods. These are accepted because they are inherited from the parent class of WOMock (NSProxy).
+
  If you wish to override this behaviour you may send the setAcceptsByDefault message passing a flag of YES, but be aware that selectors which fall through to the "accepts by default" cannot return any defined value. For control over return values the selector in question must be explicitly set up with the expectInOrder, expectOnce, expect, acceptOnce or accept methods.
+
  If a selector does appear in the lists but has been set to throw an exception an exception will be raised. It is the responsibility of the caller to avoid ambiguous list membership; for example, it does not make any sense to add a selector to both the "expected once" and the "accepted" lists.
+
  \startgroup
 */
 
 /*! Instructs the receiver to accept a selector. The following example shows how to instruct the WOMock instance mock to accept the connect selector:
-    
+
 \code
 [[mock accept] connect];
 \endcode
@@ -122,11 +122,11 @@ If the selector takes arguments then the arguments passed to the mock must match
 \code
 [[mock accept] connectTo:server] anyArguments];
 \endcode
-    
+
 You can explicitly instruct a mock to reject selectors by using the reject method. Selectors added with the accept method will be accepted by the receiver at any time, in any order, until removed with the reject method.
 
 See the WOMockTests class in WOTestSelfTests for usage examples.
-    
+
 \see WOStub::anyArguments */
 - (id)accept;
 
@@ -153,13 +153,13 @@ See the WOMockTests class in WOTestSelfTests for usage examples.
 If the selector takes arguments then the arguments passed to the mock must match those used when registering the selector with the expect method, otherwise an exception is raised. */
 - (id)expect;
 
-/*! Instructs the receiver to expect the selector once and only once. If the selector is performed twice then the second invocation will cause an exception to be raised. 
+/*! Instructs the receiver to expect the selector once and only once. If the selector is performed twice then the second invocation will cause an exception to be raised.
 
 \see accept */
 - (id)expectOnce;
 
 /*! Instructs the receiver to expect the selector as part of an ordered sequence. You can build a list of expected selectors by repeatedly calling expectInOrder with the selectors that should appear in the sequence as illustrated in this example:
-    
+
 \code
 [[mock expectInOrder] connect];
 [[mock expectInOrder] logStats];
@@ -195,9 +195,9 @@ If the selector takes arguments then the arguments passed to the mock must match
 #pragma mark -
 #pragma mark Accessors
 
-//! \name  Accessor methods 
+//! \name  Accessor methods
 //! Note that the majority of instance variables in this class do not have accessors so as to avoid namespace pollution.
-//! \startgroup 
+//! \startgroup
 
 - (BOOL)acceptsByDefault;
 - (void)setAcceptsByDefault:(BOOL)flag;
index d2ab39865a4a96259fb135e8255836578027c24c..9763b1f26b566d3fdf545daf32a1df42ba74c88c 100644 (file)
--- a/WOMock.m
+++ b/WOMock.m
@@ -45,8 +45,8 @@
 {
     // avoid infinite loops if called by subclass
     if (self != [WOMock class])
-        [NSException raise:NSInternalInconsistencyException format:@"mockForObjectClass: called from WOMock subclass"]; 
-    
+        [NSException raise:NSInternalInconsistencyException format:@"mockForObjectClass: called from WOMock subclass"];
+
     return [WOObjectMock mockForClass:aClass];
 }
 
@@ -54,7 +54,7 @@
 {
     // avoid infinite loops if called by subclass
     if (self != [WOMock class])
-        [NSException raise:NSInternalInconsistencyException format:@"mockForClass: called from WOMock subclass"]; 
+        [NSException raise:NSInternalInconsistencyException format:@"mockForClass: called from WOMock subclass"];
 
     return [WOClassMock mockForClass:aClass];
 }
@@ -63,7 +63,7 @@
 {
     // avoid infinite loops if called by subclass
     if (self != [WOMock class])
-        [NSException raise:NSInternalInconsistencyException format:@"mockForProtocol: called from WOMock subclass"]; 
+        [NSException raise:NSInternalInconsistencyException format:@"mockForProtocol: called from WOMock subclass"];
 
     return [WOProtocolMock mockForProtocol:aProtocol];
 }
@@ -72,9 +72,9 @@
 - (id)initWithObjectClass:(Class)aClass
 {
     // avoid infinite loops if called by subclass
-    if ([self class] != [WOMock class]) 
+    if ([self class] != [WOMock class])
         [NSException raise:NSInternalInconsistencyException format:@"initWithObjectClass: called from WOMock subclass"];
-    
+
     id subclass = [[WOObjectMock allocWithZone:[self zone]] initWithClass:aClass];
 
     [self dealloc];
 {
     // avoid infinite loops if called by subclass
     if ([self class] != [WOMock class])
-        [NSException raise:NSInternalInconsistencyException format:@"initWithClass: called from WOMock subclass"]; 
-    
-    id subclass = [[WOClassMock allocWithZone:[self zone]] initWithClass:aClass]; 
+        [NSException raise:NSInternalInconsistencyException format:@"initWithClass: called from WOMock subclass"];
+
+    id subclass = [[WOClassMock allocWithZone:[self zone]] initWithClass:aClass];
     [self dealloc];
-    return subclass;    
+    return subclass;
 }
 
 // a true Apple-style cluster would do this by allocating a placeholder object
 {
     // avoid infinite loops if called by subclass
     if ([self class] != [WOMock class])
-        [NSException raise:NSInternalInconsistencyException format:@"initWithProtocol: called from WOMock subclass"]; 
-    
-    id subclass = [[WOProtocolMock allocWithZone:[self zone]] initWithProtocol:aProtocol]; 
+        [NSException raise:NSInternalInconsistencyException format:@"initWithProtocol: called from WOMock subclass"];
+
+    id subclass = [[WOProtocolMock allocWithZone:[self zone]] initWithProtocol:aProtocol];
     [self dealloc];
-    return subclass;    
+    return subclass;
 }
 
 - (id)init
 
 - (id)accept
 {
-    [NSException raise:NSInternalInconsistencyException format:@"accept invoked on WOMock abstract class"]; 
+    [NSException raise:NSInternalInconsistencyException format:@"accept invoked on WOMock abstract class"];
     return nil;
 }
 
 - (id)acceptOnce
 {
-    [NSException raise:NSInternalInconsistencyException format:@"acceptOnce invoked on WOMock abstract class"]; 
+    [NSException raise:NSInternalInconsistencyException format:@"acceptOnce invoked on WOMock abstract class"];
     return nil;
 }
 
 - (id)reject
 {
-    [NSException raise:NSInternalInconsistencyException format:@"reject invoked on WOMock abstract class"]; 
+    [NSException raise:NSInternalInconsistencyException format:@"reject invoked on WOMock abstract class"];
     return nil;
 }
 
 - (id)expect
 {
-    [NSException raise:NSInternalInconsistencyException format:@"expect invoked on WOMock abstract class"]; 
+    [NSException raise:NSInternalInconsistencyException format:@"expect invoked on WOMock abstract class"];
     return nil;
 }
 
 - (id)expectOnce
 {
-    [NSException raise:NSInternalInconsistencyException format:@"expectOnce invoked on WOMock abstract class"]; 
+    [NSException raise:NSInternalInconsistencyException format:@"expectOnce invoked on WOMock abstract class"];
     return nil;
 }
 
 - (id)expectInOrder
 {
-    [NSException raise:NSInternalInconsistencyException format:@"expectInOrder invoked on WOMock abstract class"]; 
+    [NSException raise:NSInternalInconsistencyException format:@"expectInOrder invoked on WOMock abstract class"];
     return nil;
 }
 
 #pragma mark -
 #pragma mark Utility methods
 
-- (void)storeReturnValue:(NSValue *)aValue forInvocation:(NSInvocation *)invocation 
+- (void)storeReturnValue:(NSValue *)aValue forInvocation:(NSInvocation *)invocation
 {
     NSParameterAssert(invocation != nil);
     if (!aValue) return; // nothing to do
 
     size_t bufferSize = [aValue WOTest_bufferSize];
     void *buffer = malloc(bufferSize);
-    NSAssert1((buffer != NULL), @"malloc() failed (size %d)", bufferSize); 
+    NSAssert1((buffer != NULL), @"malloc() failed (size %d)", bufferSize);
     [aValue getValue:buffer];
     [invocation setReturnValue:buffer];
 }
 
 - (void)setObjCTypes:(NSString *)types forSelector:(SEL)aSelector
 {
-    [methodSignatures setObject:[NSMethodSignature WOTest_signatureBasedOnObjCTypes:[types UTF8String]] 
+    [methodSignatures setObject:[NSMethodSignature WOTest_signatureBasedOnObjCTypes:[types UTF8String]]
                          forKey:NSStringFromSelector(aSelector)];
 }
 
 
     // fallback to internal lookup
     NSMethodSignature *signature = [methodSignatures objectForKey:NSStringFromSelector(sel)];
-        
+
     // at this point it would be great to be able to improvise but it's not possible to figure out an accurate method signature
     NSAssert((signature != nil), ([NSString stringWithFormat:@"no method signature for selector %@", NSStringFromSelector(sel)]));
-    
+
     NSInvocation *forwardInvocation = [NSInvocation invocationWithMethodSignature:signature];
     [forwardInvocation setSelector:sel];
-        
+
     // store arguments in invocation
     int offset = 0;
     for (unsigned i = 0, max = [signature numberOfArguments]; i < max; i++)
     {
         const char *type = [signature getArgumentTypeAtIndex:i];    // always id, SEL, ...
-        
+
 #if defined(__ppc__)
 
         // TODO: finish version in WOStub and copy it here
         // leave the compiler warnings about "unused variable 'type'" and "unused variable 'offset'" to remind me to do it
-        // may be able to use libffi to help here    
-        
+        // may be able to use libffi to help here
+
 #elif defined(__i386__)
-            
+
         // on i386 the marg_getRef macro and its helper, marg_adjustedOffset, should work fine
         if (strcmp(type, @encode(id)) == 0)
         {
             [forwardInvocation WOTest_setArgumentValue:[NSValue valueWithBytes:ref objCType:type] atIndex:i];
         }
         else
-            [NSException raise:NSGenericException format:@"type %s not supported", type];     
-                
+            [NSException raise:NSGenericException format:@"type %s not supported", type];
+
         offset += [NSValue WOTest_sizeForType:[NSString stringWithUTF8String:type]];
-        
+
 #elif defined(__ppc64__)
         // there is no objc-msg-ppc.s so for now just omit support rather than make assumptions
 #error ppc64 not supported yet
-        
+
 #else
-        
+
 #error Unsupported architecture
-        
+
 #endif
-        
+
     }
     [self forwardInvocation:forwardInvocation]; // stores return value in invocation
-    
+
     unsigned bufferSize = [signature methodReturnLength];
     void *returnBuffer = malloc(bufferSize);
     NSAssert1((returnBuffer != NULL), @"malloc() failed (size %d)", bufferSize);
     [forwardInvocation getReturnValue:&returnBuffer];
     return returnBuffer; // TODO: cast according to the return type
 }
-    
+
 #pragma mark -
 #pragma mark Accessors
 
index 1394f1e2eafb137d2cbe61bed4145b49d16550ba..e5890e74021bb9af0c745103f0b059a94cee1f71 100644 (file)
@@ -41,8 +41,8 @@
 #pragma mark Accessors
 
     /*!
-    \name  Accessor methods 
-     \startgroup 
+    \name  Accessor methods
+     \startgroup
      */
 
 - (Class)mockedClass;
index a663bcc426f94000e31b85e55535e990f0fb952e..d1891faa8793ddcd7e21a7e698bf9425f866a90f 100644 (file)
@@ -46,7 +46,7 @@
     NSParameterAssert([NSObject WOTest_isRegisteredClass:aClass]);     // only registered classes pass (do not pass meta classes)
 
     if ((self = [super init]))
-        [self setMockedClass:aClass];                
+        [self setMockedClass:aClass];
     return self;
 }
 
 }
 
 #pragma mark -
-#pragma mark Proxy methods 
+#pragma mark Proxy methods
 
 - (void)forwardInvocation:(NSInvocation *)anInvocation
 {
     NSParameterAssert(anInvocation != nil);
-    
+
     // check if in reject list
     WO_ENUMERATE(rejected, stub)
         if ([stub matchesInvocation:anInvocation])
                 NSStringFromSelector([anInvocation selector]), NSStringFromClass([self mockedClass])];
             return;
         }
-    
+
     // check if expectedInOrder
     WO_ENUMERATE(expectedInOrder, stub)
         if ([stub matchesInvocation:anInvocation])
         {
             NSAssert2(([expectedInOrder objectAtIndex:0] == stub), @"Invocation selector %@ class %@ received out of order",
                       NSStringFromSelector([anInvocation selector]), NSStringFromClass([self mockedClass]));
-            
+
             [expectedInOrder removeObjectAtIndex:0];    // if in order, remove from head of list
-            
+
             // and move to "accepted"
             [accepted addObject:stub];
             [self storeReturnValue:[stub returnValue] forInvocation:anInvocation];
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if expected
     WO_ENUMERATE(expected, stub)
         if ([stub matchesInvocation:anInvocation])
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if accepted once
     WO_ENUMERATE(acceptedOnce, stub)
         if ([stub matchesInvocation:anInvocation])
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if accepted
     WO_ENUMERATE(accepted, stub)
         if ([stub matchesInvocation:anInvocation])
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     if ([self acceptsByDefault]) return;
-    
+
     // no matches! (should never get here)
     [NSException raise:NSInternalInconsistencyException format:@"No matching invocations found (selector %@, class %@)",
         NSStringFromSelector([anInvocation selector]), NSStringFromClass([self mockedClass])];
 
 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
 {
-    // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the 
+    // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the
     // selector for this method itself and by not sending any message that might invoke this method.")
     if (([self mockedClass] == [self class]) && (aSelector == _cmd)) return nil;
-    
-    // search only for instance methods here; forcing the programmer to use WOClassMock for searching for class methods avoids 
+
+    // search only for instance methods here; forcing the programmer to use WOClassMock for searching for class methods avoids
     // ambiguity in cases where an instance method and a class method share the same name
     return [[self mockedClass] instanceMethodSignatureForSelector:aSelector];
 }
index b286386f39a4347ef3e023a9c8298acc35983a3e..7f322638321e533045f7e5c8956be15d6a6d7448 100644 (file)
@@ -25,7 +25,7 @@
 @interface WOObjectStub : WOStub {
 
     Class           mockedClass;
-    
+
 }
 
 #pragma mark -
index f0786cd31dc80bcde8e8ad17bc2d8965cb42d918..2dfb11ab69f71610bab1ec4e0d44e3ae028ae0e9 100644 (file)
 
 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
 {
-    // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the 
+    // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the
     // selector for this method itself and by not sending any message that might invoke this method.")
     if (([self mockedClass] == [self class]) && (aSelector == _cmd)) return nil;
-    
+
     // see if method really exists in mocked class, if not forward:: will have to do something special
     return [[self mockedClass] instanceMethodSignatureForSelector:aSelector];
-}    
+}
 
 #pragma mark -
 #pragma mark NSObject protocol
             NSValue         *otherValue             = [anObject returnValue];
             id              thisException           = [self exception];
             id              otherException          = [anObject exception];
-            
+
             if ([self mockedClass] != [anObject mockedClass])
                 return NO;
-            
+
             if ([self acceptsAnyArguments] != [anObject acceptsAnyArguments])
                 return NO;
-            
+
             if (!thisInvocation && !otherInvocation) // both nil
                 invocationsAreEqual = YES;
             else if (thisInvocation && otherInvocation) // both non-nil
                 else
                     invocationsAreEqual = [thisInvocation WOTest_isEqualToInvocation:otherInvocation];
             }
-            
+
             if (!thisValue && !otherValue) // both nil
                 returnValuesAreEqual = YES;
             else if (thisValue && otherValue) // both non-nil
                 returnValuesAreEqual = [thisValue isEqual:otherValue];
-            
+
             if (!thisException && !otherException) // both nil
                 exceptionsAreEqual = YES;
             else if (thisException && otherException) // both non-nil
                 exceptionsAreEqual = [thisException isEqual:otherException];
-            
-            if (invocationsAreEqual && returnValuesAreEqual && 
+
+            if (invocationsAreEqual && returnValuesAreEqual &&
                 exceptionsAreEqual)
                 return YES;
         }
index 83a93d28824f6bdc9b486a0de57239f015db9b52..90ea3b03cfd23b0a0c1c1c966ec9cb0e4d73b47a 100644 (file)
@@ -31,7 +31,7 @@ NSString *WOStringFromProtocol(Protocol *aProtocol);
 @interface WOProtocolMock : WOMock {
 
     Protocol    *mockedProtocol;
-    
+
 }
 
 #pragma mark -
index a1877c632c30ea4e6aed5dd950a455b5a1744a78..2a9502dff7546f794d7976697dc33b13170cffde 100644 (file)
@@ -38,7 +38,7 @@
 NSString *WOStringFromProtocol(Protocol *aProtocol)
 {
     if (aProtocol == NULL) return nil;
-       return [NSString stringWithUTF8String:protocol_getName(aProtocol)];
+    return [NSString stringWithUTF8String:protocol_getName(aProtocol)];
 }
 
 @implementation WOProtocolMock
@@ -57,7 +57,7 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
     NSParameterAssert(aProtocol != NULL);
 
     // TODO: test for validity of the Protocol by checking with the runtime
-    
+
     if ((self = [super init]))
         [self setMockedProtocol:aProtocol];
     return self;
@@ -109,12 +109,12 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
 }
 
 #pragma mark -
-#pragma mark Proxy methods 
+#pragma mark Proxy methods
 
 - (void)forwardInvocation:(NSInvocation *)anInvocation
 {
     NSParameterAssert(anInvocation != nil);
-    
+
     // check if in reject list
     WO_ENUMERATE(rejected, stub)
         if ([anInvocation WOTest_isEqualToInvocation:[stub recordedInvocation]])
@@ -123,23 +123,23 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
                 NSStringFromSelector([anInvocation selector]), WOStringFromProtocol([self mockedProtocol])];
             return;
         }
-    
+
     // check if expectedInOrder
     WO_ENUMERATE(expectedInOrder, stub)
         if ([anInvocation WOTest_isEqualToInvocation:[stub recordedInvocation]])
         {
             NSAssert(([expectedInOrder objectAtIndex:0] != stub), @"invocation received out of order");
-            
+
             // if in order, remove from head of list
             [expectedInOrder removeObjectAtIndex:0];
-            
+
             // and move to "accepted"
             [accepted addObject:stub];
             [self storeReturnValue:[stub returnValue] forInvocation:anInvocation];
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if expected once
     WO_ENUMERATE(expectedOnce, stub)
         if ([anInvocation WOTest_isEqualToInvocation:[stub recordedInvocation]])
@@ -151,7 +151,7 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if expected
     WO_ENUMERATE(expected, stub)
         if ([anInvocation WOTest_isEqualToInvocation:[stub recordedInvocation]])
@@ -163,7 +163,7 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if accepted once
     WO_ENUMERATE(acceptedOnce, stub)
         if ([anInvocation WOTest_isEqualToInvocation:[stub recordedInvocation]])
@@ -175,7 +175,7 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
+
     // check if accepted
     WO_ENUMERATE(accepted, stub)
         if ([anInvocation WOTest_isEqualToInvocation:[stub recordedInvocation]])
@@ -184,10 +184,10 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
             if ([stub exception]) @throw [stub exception];
             return;
         }
-    
-    
+
+
     if ([self acceptsByDefault]) return;
-    
+
     // no matches! (should never get here)
     [NSException raise:NSInternalInconsistencyException format:@"No matching invocations found (selector %@, protocol %@)",
         NSStringFromSelector([anInvocation selector]), WOStringFromProtocol([self mockedProtocol])];
@@ -195,12 +195,12 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
 
 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
 {
-    // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the 
+    // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the
     // selector for this method itself and by not sending any message that might invoke this method.")
     if (aSelector == _cmd) return nil;
-    
-       BOOL isRequiredMethod = YES;    // no idea what to pass here
-       struct objc_method_description description = protocol_getMethodDescription([self mockedProtocol], aSelector, isRequiredMethod, YES);
+
+    BOOL isRequiredMethod = YES;    // no idea what to pass here
+    struct objc_method_description description = protocol_getMethodDescription([self mockedProtocol], aSelector, isRequiredMethod, YES);
     return [NSMethodSignature WOTest_signatureBasedOnObjCTypes:description.types];
 }
 
@@ -209,7 +209,7 @@ NSString *WOStringFromProtocol(Protocol *aProtocol)
 
 - (Protocol *)mockedProtocol
 {
-    return mockedProtocol; 
+    return mockedProtocol;
 }
 
 - (void)setMockedProtocol:(Protocol *)aMockedProtocol
index fbe5854b1d5f212da5cdbc1e07e18cb033f19abf..d63c82612d2d43cffccf9803de842e1d172388fd 100644 (file)
@@ -25,7 +25,7 @@
 @interface WOProtocolStub : WOStub {
 
     Protocol    *mockedProtocol;
-    
+
 }
 
 #pragma mark -
index 994f7fd66f6620e40e5b524fb46bb1bb89d9acf7..f01cf20cb4f6e27c0856caba775e805db82c0dc5 100644 (file)
 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
 {
     // avoid an infinite loop (docs warn "Be sure to avoid an infinite loop when necessary by checking that aSelector isn't the
-       // selector for this method itself and by not sending any message that might invoke this method.")
+    // selector for this method itself and by not sending any message that might invoke this method.")
     if (aSelector == _cmd) return nil;
 
-       Protocol *protocol = [self mockedProtocol];
-       BOOL isRequiredMethod = YES;    // no idea what to pass here
-       struct objc_method_description description = protocol_getMethodDescription(protocol, aSelector, isRequiredMethod, YES);
-    
-       // TODO: not sure how to test for missing method signatures... protocol_getMethodDescription() is not documented
-       if (description.name == NULL)
+    Protocol *protocol = [self mockedProtocol];
+    BOOL isRequiredMethod = YES;    // no idea what to pass here
+    struct objc_method_description description = protocol_getMethodDescription(protocol, aSelector, isRequiredMethod, YES);
+
+    // TODO: not sure how to test for missing method signatures... protocol_getMethodDescription() is not documented
+    if (description.name == NULL)
         [NSException raise:NSInternalInconsistencyException format:@"No method signature for selector %@ in %@ protocol",
-                NSStringFromSelector(aSelector), WOStringFromProtocol(protocol)];      
+            NSStringFromSelector(aSelector), WOStringFromProtocol(protocol)];
     return [NSMethodSignature WOTest_signatureBasedOnObjCTypes:description.types];
-}    
+}
 
 #pragma mark -
 #pragma mark NSObject protocol
             NSValue         *otherValue             = [anObject returnValue];
             id              thisException           = [self exception];
             id              otherException          = [anObject exception];
-            
+
             if ([self mockedProtocol] != [anObject mockedProtocol])
                 return NO;
-            
+
             if ([self acceptsAnyArguments] != [anObject acceptsAnyArguments])
                 return NO;
-            
+
             if (!thisInvocation && !otherInvocation) // both nil
                 invocationsAreEqual = YES;
             else if (thisInvocation && otherInvocation) // both non-nil
                 else
                     invocationsAreEqual = [thisInvocation WOTest_isEqualToInvocation:otherInvocation];
             }
-            
+
             if (!thisValue && !otherValue) // both nil
                 returnValuesAreEqual = YES;
             else if (thisValue && otherValue) // both non-nil
                 returnValuesAreEqual = [thisValue isEqual:otherValue];
-            
+
             if (!thisException && !otherException) // both nil
                 exceptionsAreEqual = YES;
             else if (thisException && otherException) // both non-nil
                 exceptionsAreEqual = [thisException isEqual:otherException];
-            
-            if (invocationsAreEqual && returnValuesAreEqual && 
+
+            if (invocationsAreEqual && returnValuesAreEqual &&
                 exceptionsAreEqual)
                 return YES;
         }
 
 - (Protocol *)mockedProtocol
 {
-    return mockedProtocol; 
+    return mockedProtocol;
 }
 
 @end
index 10a3e1991eab41330702e16b03e802b745189c9b..188fe49e433021b31ea62f522e3675ed4a3a560d 100644 (file)
--- a/WOStub.h
+++ b/WOStub.h
 
 /*! The WOStub class provides a temporary "trampoline" object that can be used to record invocations (selectors and arguments) and desired return values. It is a "stub" because it is a temporary object that operates behind the scenes and is effectively indistinguishable from the object for which it temporarily stands in. It is a "trampoline" because it serves to bounce back the invocations and desired return values to the object for which it temporarily stands in. */
 @interface WOStub : NSProxy {
-    
+
     id              delegate;
-    
+
     NSInvocation    *invocation;
-    
+
     NSValue         *returnValue;
-        
+
     id              exception;
-    
+
     /*! YES if the stub should accept any arguments. The default behaviour (NO) indicates that the stub should only accept the arguments that were passed when it was first created and any discrepancies will result in an exception. */
     BOOL            acceptsAnyArguments;
 }
index 663e9366b8946821216741bf8d6bdb44e7805476..5c6cba109582d6d0e993f2dd879037cada5eb58a 100644 (file)
--- a/WOStub.m
+++ b/WOStub.m
@@ -37,7 +37,7 @@
 
 - (id)init
 {
-    return self; // super (NSProxy) has no init method    
+    return self; // super (NSProxy) has no init method
 }
 
 - (void)dealloc
@@ -84,7 +84,7 @@
 }
 
 #pragma mark -
-#pragma mark Proxy methods 
+#pragma mark Proxy methods
 
 - (void)forwardInvocation:(NSInvocation *)anInvocation
 {
 }
 
 /*
+
  http://lists.apple.com/archives/cocoa-dev/2004/Jun/msg00990.html
+
  "On PPC, the prearg area is used to store the 13 floating-point parameter registers, which may contain method parameters that need to be restored when the marg_list is used. The i386 function call ABI has no additional registers to be saved, so its prearg area is empty. The implementations of _objc_msgForward() and objc_msgSendv() in objc4's objc-msg-ppc.s contain more details that may be useful to you.
- In general, you probably want to avoid marg_list and objc_msgSendv(). Together they are primarily an implementation detail of forward:: ." 
+
+ In general, you probably want to avoid marg_list and objc_msgSendv(). Together they are primarily an implementation detail of forward:: ."
 
  (Greg Parker, Apple)
+
  */
 
 - forward:(SEL)sel :(marg_list)args
     // let standard event flow take place (but note that NSProxy implementation raises so subclasses must do the real work)
     if ([self methodSignatureForSelector:sel])
       return [super forward:sel :args];
-    
+
     // fallback to internal lookup
     NSMethodSignature *signature = [[delegate methodSignatures] objectForKey:NSStringFromSelector(sel)];
-    
+
     // at this point it would be great to be able to improvise but it's not possible to figure out an accurate method signature
     NSAssert((signature != nil), ([NSString stringWithFormat:@"no method signature for selector %@", NSStringFromSelector(sel)]));
-    
+
     NSInvocation *forwardInvocation = [NSInvocation invocationWithMethodSignature:signature];
     [forwardInvocation setSelector:sel];
-    
-    
+
+
     // store arguments in invocation
     int offset = 0;
     for (unsigned i = 0, max = [signature numberOfArguments]; i < max; i++)
     {
         const char *type = [signature getArgumentTypeAtIndex:i];    // always id, SEL, ...
-                
+
 #if defined(__ppc__)
 
         // TODO: finish this implementation and copy it (or otherwise make it available) to WOMock.m
         // leave the compiler warnings about "unused variable 'type'" and "unused variable 'offset'" to remind me to do it
-        
+
         // the PPC ABI has special conventions for floats, doubles, structs
 
         // contents of floating point registers f1 through f13 stored at args + 0 through args + 96
         // 6th param: r8 args + (13 * 8) + 44
         // 7th param: r9 args + (13 * 8) + 48
         // 8th param: r10 args + (13 * 8) + 52
-        // the remaining parameters are on the stack (starting at args + (13 * 8) + 56) 
+        // the remaining parameters are on the stack (starting at args + (13 * 8) + 56)
         // note that marg_prearg_size is defined in the headers for ppc and equals 128 (13 * 8 + 24 bytes for linkage area)
-        
+
         // from http://darwinsource.opendarwin.org/10.4.3/objc4-267/runtime/Messengers.subproj/objc-msg-ppc.s
 //        typedef struct objc_sendv_margs {
-//            double   floatingPointArgs[13];
-//            int     linkageArea[6];
-//            int              registerArgs[8];
-//            int              stackArgs[variable];
+//            double    floatingPointArgs[13];
+//            int       linkageArea[6];
+//            int       registerArgs[8];
+//            int       stackArgs[variable];
 //        };
-//        
+//
 //        if (strcmp(type, @encode(float)) == 0)
 //        {}
 //        else if (strcmp(type, @encode(double)) == 0)
 //        {}
 //        else
-        
+
 #elif defined(__i386__)
 
         // on i386 the marg_getRef macro and its helper, marg_adjustedOffset, should work fine
         }
         else
             [NSException raise:NSGenericException format:@"type %s not supported", type];
-        
+
         offset += [NSValue WOTest_sizeForType:[NSString stringWithUTF8String:type]];
 
 #elif defined(__ppc64__)
         // there is no objc-msg-ppc.s so for now just omit support rather than make assumptions
 #error ppc64 not supported yet
-            
+
 #else
 
 #error Unsupported architecture
 
 #endif
-        
+
     }
     [self forwardInvocation:forwardInvocation];
     return nil; // nobody cares what a stub returns
 - (NSInvocation *)recordedInvocation
 {
     NSInvocation *recordedInvocation = [self invocation];
-    NSAssert((recordedInvocation != nil), @"WOStub sent recordedInvocation but no invocation yet recorded");    
+    NSAssert((recordedInvocation != nil), @"WOStub sent recordedInvocation but no invocation yet recorded");
     return recordedInvocation;
 }
 
 - (NSInvocation *)invocation
 {
-    return [[invocation retain] autorelease]; 
+    return [[invocation retain] autorelease];
 }
 
 - (void)setInvocation:(NSInvocation *)anInvocation
 
 - (NSValue *)returnValue
 {
-    return [[returnValue retain] autorelease]; 
+    return [[returnValue retain] autorelease];
 }
 
 - (void)setReturnValue:(NSValue *)aReturnValue
 
 - (id)exception
 {
-    return [[exception retain] autorelease]; 
+    return [[exception retain] autorelease];
 }
 
 - (void)setException:(id)anException
index 12b82e298853d1a6d96ef1000bbdbcaf3028058d..5ba51f2c03c6827c1d414b70947beb33eacc61c8 100644 (file)
@@ -34,7 +34,7 @@
 @interface WOTestApplicationTestsController : NSObject {
 
     unsigned    _trimPathComponents;
-    
+
 }
 
 //! For example, if your test controller was implemented in a source file at:
index d5e1865841d332b710d0c9504b65f6f5415a8bbb..cb27dca6f94051ccac74d3a3ba62f3a83358e385 100644 (file)
@@ -35,7 +35,7 @@
 {
     static int32_t initialized = 0;
     if (OSAtomicIncrement32Barrier(&initialized) != 1) return;  // do this once only
-        
+
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
     (void)[[self alloc] initWithPath:__FILE__ keepComponents:3]; // will release self after running tests
     [pool release];
@@ -61,14 +61,14 @@ extern NSString *NSApplicationDidFinishLaunchingNotification;
         unsigned componentCount = [components count];
         NSAssert(componentCount > count, @"componentCount must be greater than count");
         _trimPathComponents = componentCount - count;
-        
+
         // wait until the app has finish launching before running the tests; means we can test stuff in nibs etc
         NSAssert((NSApplicationDidFinishLaunchingNotification != NULL), @"NSApplicationDidFinishLaunchingNotification not defined");
-        [[NSNotificationCenter defaultCenter] addObserver:self 
-                                                 selector:@selector(runTests:) 
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(runTests:)
                                                      name:NSApplicationDidFinishLaunchingNotification
                                                    object:nil];
-        
+
         [self performSelector:@selector(applicationFailedToFinishLaunching:) withObject:nil afterDelay:10.0];
     }
     return self;
@@ -77,11 +77,11 @@ extern NSString *NSApplicationDidFinishLaunchingNotification;
 - (void)runTests:(NSNotification *)aNotification
 {
     [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(applicationFailedToFinishLaunching:) object:nil];
-    
+
     WOTest *tester = [WOTest sharedInstance];
     [tester setTrimInitialPathComponents:_trimPathComponents];
     [tester runAllTests];
-    
+
     [[NSNotificationCenter defaultCenter] removeObserver:self];
     [self release];                                 // balance alloc/init in load method
 }
index bd6ed5326d7230ba1e2419dc76d67df138ea6ecf..be1a35ca1c99f0639dff94d9996f4ec3fd1a04bd 100644 (file)
@@ -35,7 +35,7 @@
     static int32_t initialized = 0;
     if (OSAtomicIncrement32Barrier(&initialized) != 1)
         return;
-        
+
     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
     char *inject = getenv("WOTestInjectBundle");
     if (inject)
index 800ededd7caff56d6f605a698f2f132dc93488e9..6256fa4145620f7b89ea8d4786bc6bf64eef8016 100644 (file)
@@ -24,7 +24,7 @@
 @interface WOTest : NSObject {
 
     NSDate      *startDate;
-    
+
     unsigned    classesWithTests;
     unsigned    classesWithoutTests;
     unsigned    methodsWithTests;
     unsigned    testsPassed;
     unsigned    testsFailed;
     unsigned    uncaughtExceptions;
-    
+
     //! test sense inversion: should only be used during WOTest self-testing
     unsigned    testsFailedExpected;
     unsigned    testsPassedUnexpected;
     BOOL        expectFailures;
-    
+
     //! low-level exception handling inversion: should only be used during WOTest self-testing
     unsigned    lowLevelExceptionsExpected;
     unsigned    lowLevelExceptionsUnexpected;
 
     //! Optionally refrain from handling low level exceptions
     BOOL        handlesLowLevelExceptions;
-    
+
     //! Internal use only: used for keeping track of whether low-level exception handlers have been installed or not
     //! Necessary because tested methods may change the low-level-exception-catching status mid-test
     BOOL        lowLevelExceptionHandlerInstalled;
-    
+
     //! 0 = mostly silent operation; 1 = verbose; 2 = very verbose
     unsigned    verbosity;
-    
+
     //! Optionally trim leading path components when printing path names to console.
     unsigned    trimInitialPathComponents;
-    
+
     //! Cache last reported path and last reported line number for use when printing warnings and errors which don't include file and line information
     NSString    *lastReportedFile;
     int         lastReportedLine;
-    
+
     //! Defaults to YES.
     BOOL        warnsAboutSignComparisons;
 }
@@ -67,7 +67,7 @@
 #pragma mark -
 #pragma mark Singleton pattern enforcement methods
 
-/*! \name Singleton pattern enforcement methods 
+/*! \name Singleton pattern enforcement methods
 \startgroup */
 
 + (WOTest *)sharedInstance;
@@ -77,7 +77,7 @@
 #pragma mark -
 #pragma mark Utility methods
 
-/*! \name Utility methods 
+/*! \name Utility methods
     \startgroup */
 
 /*! Returns an NSString based on sending the "description" selector to anObject, compressing whitespace and truncating if necessary at index and appending an ellipsis. Returns nil if anObject is nil. Optionally returns YES or NO indirectyl via /p didTruncate to indicate whether truncation actually occurred. Pass \p index of 0 to return an untruncated, uncompressed description. */
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Test-running methods
 
-/*! \name Test-running test methods 
+/*! \name Test-running test methods
     \startgroup */
 
 /*! Runs all tests currently visible in the runtime. Returns YES if all tests pass, NO if any test fails. */
 
 - (void)growlNotifyTitle:(NSString *)title message:(NSString *)message isWarning:(BOOL)isWarning sticky:(BOOL)sticky;
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Logging methods
 
-//! \name Logging methods 
+//! \name Logging methods
 //! \startgroup
 
 //! Keep track of last known file and line number
 
 //! \endgroup
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Empty (do-nothing) test methods
 
-/*! \name Empty (do-nothing) test methods 
+/*! \name Empty (do-nothing) test methods
     \startgroup */
 
 /*! An empty test which always passes. */
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Boolean test methods
 
-/*! \name Boolean test methods 
+/*! \name Boolean test methods
     \startgroup */
 
 - (void)testTrue:(BOOL)expr inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark NSValue-based tests
 
-/*! \name NSValue-based tests 
+/*! \name NSValue-based tests
     \startgroup */
 
 - (void)testValue:(NSValue *)actual isEqualTo:(NSValue *)expected inFile:(char *)path atLine:(int)line;
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Pointer to void test methods
 
-/*! \name Pointer to void test methods 
+/*! \name Pointer to void test methods
     \startgroup */
 
 - (void)testNil:(void *)pointer inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark int test methods
 
-/*! \name int test methods 
+/*! \name int test methods
     \startgroup */
 
 /*! The WO_TEST_IS_INT macro uses \@encode(typeof()) to pass a string encoding of the type. */
 #pragma mark -
 #pragma mark unsigned test methods
 
-/*! \name unsigned test methods 
+/*! \name unsigned test methods
     \startgroup */
 
 /*! The WO_TEST_IS_UNSIGNED macro uses \@encode(typeof()) to pass a string encoding of the type. */
 #pragma mark -
 #pragma mark float test methods without error margins
 
-/*! \name float test methods without error margins 
+/*! \name float test methods without error margins
     \startgroup */
 
 /*! The WO_TEST_IS_FLOAT macro uses \@encode(typeof()) to pass a string encoding of the type. */
 #pragma mark -
 #pragma mark float test methods with error margins
 
-/*! \name float test methods with error margins 
+/*! \name float test methods with error margins
     \startgroup */
 
 - (void)testFloatPositive:(float)aFloat withinError:(float)error inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark double test methods without error margins
 
-/*! \name double test methods without error margins 
+/*! \name double test methods without error margins
     \startgroup */
 
 /*! The WO_TEST_IS_DOUBLE macro uses \@encode(typeof()) to pass a string encoding of the type. */
 #pragma mark -
 #pragma mark double test methods with error margins
 
-/*! \name double test methods with error margins 
+/*! \name double test methods with error margins
     \startgroup */
 
 - (void)testDoublePositive:(double)aDouble withinError:(double)error inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark Object test methods
 
-/*! \name Object test methods 
+/*! \name Object test methods
     \startgroup */
 
 - (void)testObject:(id)actual isEqualTo:(id)expected inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark NSString test methods
 
-/*! \name NSString test methods 
+/*! \name NSString test methods
     \startgroup */
 
 - (void)testString:(NSString *)actual isEqualTo:(NSString *)expected inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark NSArray test methods
 
-/*! \name NSArray test methods 
+/*! \name NSArray test methods
     \startgroup */
 
 - (void)testArray:(NSArray *)actual isEqualTo:(NSArray *)expected inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark NSDictionary test methods
 
-/*! \name NSDictionary test methods 
+/*! \name NSDictionary test methods
     \startgroup */
 
 - (void)testDictionary:(NSDictionary *)actual isEqualTo:(NSDictionary *)expected inFile:(char *)path atLine:(int)line;
 #pragma mark -
 #pragma mark Exception test methods
 
-/*! \name Exception test methods 
+/*! \name Exception test methods
     \startgroup */
 
 - (void)testThrowsException:(id)exception inFile:(char *)path atLine:(int)line;
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Random value generator methods
 
 /*! \name Random value generator methods
 
 /*! \endgroup */
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Accessors
 
-//! \name Accessors 
+//! \name Accessors
 //! \startgroup
 
 - (NSDate *)startDate;
index f30ef24177802d6060879d08c7590823d7c07443..63e241ec9a1e352da84e88f654b48f9e98b44a16 100644 (file)
@@ -84,18 +84,18 @@ static ExceptionHandlerUPP      WOOldLowLevelExceptionHandler;
 typedef struct WOJumpBuffer {
     unsigned long eax;      // store/restore
     unsigned long ebx;      // store/restore
-    unsigned long ecx; 
+    unsigned long ecx;
     unsigned long edx;
     unsigned long edi;      // store/restore
     unsigned long esi;      // store/restore
     unsigned long ebp;      // store/restore
     unsigned long esp;      // store/restore
-    unsigned long ss; 
-    unsigned long eflags;  
-    unsigned long cs; 
-    unsigned long ds; 
-    unsigned long es; 
-    unsigned long fs; 
+    unsigned long ss;
+    unsigned long eflags;
+    unsigned long cs;
+    unsigned long ds;
+    unsigned long es;
+    unsigned long fs;
     unsigned long gs;
 } WOJumpBuffer;
 static volatile WOJumpBuffer WOLowLevelExceptionJumpBuffer;
@@ -118,18 +118,18 @@ OSStatus WOLowLevelExceptionHandler(ExceptionInformation *theException)
         fprintf(stderr, "error: WOTest internal error (unexpected exception in WOLowLevelExceptionHandler)\n");
         fprintf(stderr, "Exception type: %lu\n", (unsigned long)(theException->theKind));
         fflush(NULL);
-        
+
         // forwarding to old exception handler doesn't seem to work (get into infinite loop)
         //return InvokeExceptionHandlerUPP(theException, WOOldLowLevelExceptionHandler);
         _exit(EXIT_FAILURE);
     }
-    
+
     WOLastLowLevelException     = theException->theKind;
     WOTestCanJump               = NO;
 
     // set flag to indicate that an exception was triggerd
     WOTestExceptionTriggered    = 1;
-    
+
     // will resume execution at previously marked "safe place": longjmp would be fine here
 #ifdef __i386__
     // set only the registers that setjmp() saves and longjmp() restores
@@ -140,10 +140,10 @@ OSStatus WOLowLevelExceptionHandler(ExceptionInformation *theException)
     theException->registerImage->EDI    = WOLowLevelExceptionJumpBuffer.edi;
     theException->registerImage->ESI    = WOLowLevelExceptionJumpBuffer.esi;
     theException->registerImage->ESP    = WOLowLevelExceptionJumpBuffer.esp;
-    
+
     // clear out exception state (probably not necessary)
     theException->info.memoryInfo = NULL;
-    
+
 #elif defined (__ppc__)
     theException->machineState->PC  = WOProgramCounter;
     // TODO: must restore more state here
@@ -196,7 +196,7 @@ OSStatus WOLowLevelExceptionHandler(ExceptionInformation *theException)
             if ((self = [super init]))
             {
                 // once-off initialization and setting of defaults:
-                self->handlesLowLevelExceptions = YES; 
+                self->handlesLowLevelExceptions = YES;
                 self->warnsAboutSignComparisons = YES;
             }
             WOTestSharedInstance = self;
@@ -266,7 +266,7 @@ OSStatus WOLowLevelExceptionHandler(ExceptionInformation *theException)
 {
     if (didTruncate)    *didTruncate    = NO;
     NSString            *description    = nil;
-    if (!anObject) 
+    if (!anObject)
         description = @"(nil)";
     else
     {
@@ -367,19 +367,19 @@ OSStatus WOLowLevelExceptionHandler(ExceptionInformation *theException)
                 NSDate              *startMethod    = [NSDate date];
                 SEL                 preflight       = @selector(preflight);
                 SEL                 postflight      = @selector(postflight);
-                
+
                 _WOLog(@"Running test method %@", method);
                 @try
                 {
                     // minimize time spent with exception handlers in place
                     [self installLowLevelExceptionHandler];
-                    
+
                     // record program counter and some other registers right now
 #ifdef __i386__
-                    // LowLevelABI.pdf says "EDI, ESI, EBX, EBP" are the preserved registers (across function calls)                    
+                    // LowLevelABI.pdf says "EDI, ESI, EBX, EBP" are the preserved registers (across function calls)
                     // ebp is the "saved frame pointer": "the base address of the caller's stack frame"
                     // eax is used to return pointer and integral results to callers: "The called function places integral or pointer results in EAX"
-                    
+
                     // info on inline assembly: http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
                     __asm__ volatile("movl %%eax, %0\n" : "=m" (WOLowLevelExceptionJumpBuffer.eax));
                     __asm__ volatile("movl %%ebx, %0\n" : "=m" (WOLowLevelExceptionJumpBuffer.ebx));
@@ -400,16 +400,16 @@ OSStatus WOLowLevelExceptionHandler(ExceptionInformation *theException)
 #error Unsupported architecture
 #endif
                     WOTestCanJump = YES;
-                    
+
                     goto jump_point; // necessary to silence compiler warning about unused label
 jump_point:
                     // if flag set, that means we crashed: throw an exception
                     if (WOTestExceptionTriggered)
                     {
-                        WOTestExceptionTriggered = 0;                        
+                        WOTestExceptionTriggered = 0;
                         @throw [WOTestLowLevelException exceptionWithType:WOLastLowLevelException];
                     }
-                    
+
                     if ([self isClassMethod:method])
                     {
                         if ([NSObject WOTest_class:aClass respondsToSelector:preflight])
@@ -435,7 +435,7 @@ jump_point:
                         }
                         else
                         {
-                            [self writeError:@"Class %@ must respond to the alloc, init and release selectors", 
+                            [self writeError:@"Class %@ must respond to the alloc, init and release selectors",
                                 NSStringFromClass(aClass)];
                             [self writeLastKnownLocation];
                         }
@@ -460,7 +460,7 @@ jump_point:
                 }
                 @catch (id e)
                 {
-                    [self writeError:@"uncaught exception (%@) in test method %@", [NSException WOTest_descriptionForException:e], 
+                    [self writeError:@"uncaught exception (%@) in test method %@", [NSException WOTest_descriptionForException:e],
                         method];
                     [self writeLastKnownLocation];
                     noTestFailed = NO;
@@ -478,7 +478,7 @@ jump_point:
     }
     @catch (id e)
     {
-        [self writeError:@"uncaught exception (%@) testing class %@", [NSException WOTest_descriptionForException:e], 
+        [self writeError:@"uncaught exception (%@) testing class %@", [NSException WOTest_descriptionForException:e],
             NSStringFromClass(aClass)];
         [self writeLastKnownLocation];
         noTestFailed = NO;
@@ -495,17 +495,17 @@ jump_point:
 {
     // return an array of class names
     NSMutableArray *testableClasses = [NSMutableArray array];
-    
+
     unsigned    classCount                 = 0; // the total number of classes
     unsigned    conformingClassCount       = 0; // classes conforming to WOTest
     unsigned    nonconformingClassCount    = 0; // unconforming classes
     unsigned    excludedClassCount         = 0; // excluded classes
-    unsigned    exceptionCount             = 0; // classes provoking exceptions    
-    
+    unsigned    exceptionCount             = 0; // classes provoking exceptions
+
     int         numClasses                  = 0;
     int         newNumClasses               = objc_getClassList(NULL, 0);
     Class       *classes                    = NULL;
-    
+
     // get a list of all classes on the system
     while (numClasses < newNumClasses)
     {
@@ -515,30 +515,30 @@ jump_point:
         NSAssert1((classes != NULL), @"realloc() failed (size %d)", bufferSize);
         newNumClasses       = objc_getClassList(classes, numClasses);
     }
-    
-    @try 
+
+    @try
     {
         if (classes)
-        {   
+        {
             // skip over some classes because they not only cause exceptions but also spew out ugly console messages
             SInt32 systemVersion;
             Gestalt(gestaltSystemVersion, &systemVersion);
-            systemVersion = systemVersion & 0x0000ffff; // Apple instructs to ignore the high-order word    
+            systemVersion = systemVersion & 0x0000ffff; // Apple instructs to ignore the high-order word
 
             NSArray *excludedClasses = (systemVersion < 0x00001040) ?
                 [NSArray arrayWithObjects: @"Protocol", @"List", @"Object", @"_NSZombie", nil] :                        // 10.3
                 [NSArray arrayWithObjects: @"Protocol", @"List", @"Object", @"_NSZombie", @"NSATSGlyphGenerator", nil]; // 10.4
-            
+
             if ([self verbosity] > 1)
                 _WOLog(@"Examining classes for WOTest protocol compliance");
-            
+
             for (int i = 0; i < newNumClasses; i++)
             {
                 classCount++;
-                
+
                 Class       aClass      = classes[i];
                 NSString    *className  = NSStringFromClass(aClass);
-                
+
                 @try
                 {
                     if ([excludedClasses containsObject:className])
@@ -572,13 +572,13 @@ jump_point:
             }
             free(classes);
         }
-        
+
     }
     @catch (id e)
     {
         _WOLog(@"Uncaught exception...");
     }
-        
+
     _WOLog(@"Runtime Summary:\n"
            @"Total classes:                                         %d\n"
            @"Classes which conform to the WOTest protocol:          %d\n"
@@ -590,7 +590,7 @@ jump_point:
            nonconformingClassCount,
            excludedClassCount,
            exceptionCount);
-    
+
     return [testableClasses sortedArrayUsingSelector:@selector(compare:)];
 }
 
@@ -598,7 +598,7 @@ jump_point:
 {
     NSArray         *allClasses = [self testableClasses];
     NSMutableArray  *classNames = [NSMutableArray array];
-    
+
     if (aBundle)    // only search if actually passed a non-nil bundle
     {
         // add only classes that match the passed bundle and conform to WOTest
@@ -610,7 +610,7 @@ jump_point:
                 [classNames addObject:className];
         }
     }
-    
+
     // return autoreleased, immutable NSArray
     return [NSArray arrayWithArray:classNames];
 }
@@ -619,9 +619,9 @@ jump_point:
 {
     // catch crashes caused by passing an "id" instead of a "Class"
     NSParameterAssert([NSObject WOTest_isRegisteredClass:aClass] || [NSObject WOTest_isMetaClass:aClass]);
-    
+
     NSMutableArray *methodNames = [NSMutableArray array];
-    @try 
+    @try
     {
         NSString *prefix = @"-";            // default prefix (instance methods)
         if (class_isMetaClass(aClass))
@@ -632,21 +632,21 @@ jump_point:
             Class   metaClass       = object_getClass(aClass);
             NSArray *classMethods   = [self testableMethodsFrom:metaClass];
             [methodNames addObjectsFromArray:classMethods];
-        }        
-        
-               unsigned int count;
-               Method *methods = class_copyMethodList(aClass, &count);
-               if (methods)
-               {
-                       for (unsigned int i = 0, max = count; i < max; i++)
-                       {
-                               SEL                     aSelector       = method_getName(methods[i]);
-                               NSString        *name           = NSStringFromSelector(aSelector);
-                               if (name && [name hasPrefix:@"test"])
-                                       [methodNames addObject:[NSString stringWithFormat:@"%@%@", prefix, name]];
-                       }
-                       free(methods);
-               }
+        }
+
+        unsigned int count;
+        Method *methods = class_copyMethodList(aClass, &count);
+        if (methods)
+        {
+            for (unsigned int i = 0, max = count; i < max; i++)
+            {
+                SEL         aSelector   = method_getName(methods[i]);
+                NSString    *name       = NSStringFromSelector(aSelector);
+                if (name && [name hasPrefix:@"test"])
+                    [methodNames addObject:[NSString stringWithFormat:@"%@%@", prefix, name]];
+            }
+            free(methods);
+        }
     }
     @catch (id e)
     {
@@ -654,7 +654,7 @@ jump_point:
             NSStringFromClass(aClass)];
         [self writeError:error];
     }
-    
+
     return [methodNames sortedArrayUsingSelector:@selector(compare:)];
 }
 
@@ -679,28 +679,28 @@ jump_point:
            testsPassed,    testsFailedExpected,    successRate,
            testsFailed,    testsPassedUnexpected,  failureRate,
            uncaughtExceptions,
-           lowLevelExceptionsUnexpected, lowLevelExceptionsExpected, 
+           lowLevelExceptionsUnexpected, lowLevelExceptionsExpected,
            -[[self startDate] timeIntervalSinceNow]);
-    
+
     if (testsRun == 0)
         _WOLog(@"warning: no tests were run\n");
-    
+
     // TODO: make Growl notifications optional
     // TODO: include information about project being tested in Growl notification title
     // TODO: add options for showing coalesced growl notifications showing individual test failures (with path and line info)
     // TODO: make clicking on notification bring Xcode to the front, or open the file with the last failure in it etc
-    NSString *status = [NSString stringWithFormat:@"%d tests passed, %d tests failed", 
+    NSString *status = [NSString stringWithFormat:@"%d tests passed, %d tests failed",
         testsPassed + testsFailedExpected, testsFailed + testsPassedUnexpected];
-        
+
     if ([self testsWereSuccessful])
         [self growlNotifyTitle:@"WOTest run successful" message:status isWarning:NO sticky:NO];
     else
     {
-        _WOLog(@"error: testing did not complete without errors\n");    
+        _WOLog(@"error: testing did not complete without errors\n");
         [self growlNotifyTitle:@"WOTest run failed" message:status isWarning:YES sticky:YES];
-        
+
     }
-    
+
     // reset start date
     [self setStartDate:nil];
 }
@@ -723,7 +723,7 @@ jump_point:
 }
 
 - (void)removeLowLevelExceptionHandler
-{        
+{
     if (lowLevelExceptionHandlerInstalled)
     {
         DisposeExceptionHandlerUPP(InstallExceptionHandler(WOOldLowLevelExceptionHandler));
@@ -738,18 +738,18 @@ jump_point:
 {
     NSParameterAssert(title != nil);
     NSParameterAssert(message != nil);
-    
+
     // clean up enviroment a bit (hides possible warnings caused if these set for WOTestRunner)
     NSMutableDictionary *environment = [NSMutableDictionary dictionaryWithDictionary:[[NSProcessInfo processInfo] environment]];
     [environment removeObjectForKey:@"DYLD_INSERT_LIBRARIES"];
     [environment removeObjectForKey:@"WOTestBundleInjector"];
-    
+
     NSTask *task = [[[NSTask alloc] init] autorelease];
     [task setLaunchPath:@"/usr/bin/env"];   // use env so as to pick up PATH, if set
     [task setEnvironment:environment];
     NSMutableArray *arguments = [NSMutableArray arrayWithObjects:@"growlnotify",
-        @"--name",      @"com.wincent.WOTest", 
-        @"--appIcon",   @"Xcode", 
+        @"--name",      @"com.wincent.WOTest",
+        @"--appIcon",   @"Xcode",
         @"--priority",  (isWarning ? @"2" : @"0"),
         @"--message",   message,
         title,          nil];
@@ -773,7 +773,7 @@ jump_point:
 {
     NSParameterAssert(path != NULL);
     NSString *pathString = [NSString stringWithUTF8String:path];
-    
+
     unsigned trim = [self trimInitialPathComponents];
     if (trim == 0) return pathString;
     if (![pathString isAbsolutePath]) return pathString;    // only trim absolute paths
@@ -784,8 +784,8 @@ jump_point:
     return [NSString pathWithComponents:[components subarrayWithRange:NSMakeRange(trim + 1, count - trim - 1)]];
 }
 
-- (void)writePassed:(BOOL)passed 
-             inFile:(char *)path 
+- (void)writePassed:(BOOL)passed
+             inFile:(char *)path
              atLine:(int)line
             message:(NSString *)message, ...
 {
@@ -818,7 +818,7 @@ jump_point:
         {
             [self writeErrorInFile:path atLine:line message:[NSString stringWithFormat:@"Failed: %@", string]];
             testsFailed++;
-        }    
+        }
     }
 }
 
@@ -845,7 +845,7 @@ jump_point:
     va_end(args);
 }
 
-- (void)writeWarningInFile:(char *)path atLine:(int)line message:(NSString *)message, ... 
+- (void)writeWarningInFile:(char *)path atLine:(int)line message:(NSString *)message, ...
 {
     va_list args;
     va_start(args, message);
@@ -861,7 +861,7 @@ jump_point:
     uncaughtExceptions++;
 }
 
-- (void)writeStatusInFile:(char *)path atLine:(int)line message:(NSString *)message, ... 
+- (void)writeStatusInFile:(char *)path atLine:(int)line message:(NSString *)message, ...
 {
     va_list args;
     va_start(args, message);
@@ -877,7 +877,7 @@ jump_point:
     va_start(args, message);
     NSString *status = [NSString WOTest_stringWithFormat:message arguments:args];
     _WOLog(@"%@", status);
-    va_end(args);    
+    va_end(args);
 }
 
 - (void)writeWarning:(NSString *)message, ...
@@ -886,7 +886,7 @@ jump_point:
     va_start(args, message);
     NSString *warning = [NSString WOTest_stringWithFormat:message arguments:args];
     _WOLog(@"warning: %@", warning); // older versions of Xcode required initial colons "::" to show this as a warning
-    va_end(args);    
+    va_end(args);
 }
 
 - (void)writeError:(NSString *)message, ...
@@ -898,7 +898,7 @@ jump_point:
     va_end(args);
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Empty (do-nothing) test methods
 
 - (void)passTestInFile:(char *)path atLine:(int)line
@@ -911,7 +911,7 @@ jump_point:
     [self writePassed:NO inFile:path atLine:line message:@"(always fails)"];
 }
 
-#pragma mark - 
+#pragma mark -
 #pragma mark Boolean test methods
 
 - (void)testTrue:(BOOL)expr inFile:(char *)path atLine:(int)line
@@ -932,7 +932,7 @@ jump_point:
     NSParameterAssert(actual);
     NSParameterAssert(expected);
     BOOL equal = NO;
-        
+
     // NSValue category will throw an exception for invalid input(s)
     @try {
         equal = [actual WOTest_testIsEqualToValue:expected];
@@ -952,7 +952,7 @@ jump_point:
     NSParameterAssert(actual);
     NSParameterAssert(expected);
     BOOL equal = NO;
-    
+
     // NSValue category will throw an exception for invalid input(s)
     @try {
         equal = [actual WOTest_testIsEqualToValue:expected];
@@ -972,7 +972,7 @@ jump_point:
     NSParameterAssert(actual);
     NSParameterAssert(expected);
     BOOL greaterThan = NO;
-    
+
     // NSValue category will throw an exception for invalid input(s)
     @try {
         greaterThan = [actual WOTest_testIsGreaterThanValue:expected];
@@ -992,7 +992,7 @@ jump_point:
     NSParameterAssert(actual);
     NSParameterAssert(expected);
     BOOL notGreaterThan = NO;
-    
+
     // NSValue category will throw an exception for invalid input(s)
     @try {
         notGreaterThan = [actual WOTest_testIsNotGreaterThanValue:expected];
@@ -1012,7 +1012,7 @@ jump_point:
     NSParameterAssert(actual);
     NSParameterAssert(expected);
     BOOL lessThan = NO;
-    
+
     // NSValue category will throw an exception for invalid input(s)
     @try {
         lessThan = [actual WOTest_testIsLessThanValue:expected];
@@ -1032,7 +1032,7 @@ jump_point:
     NSParameterAssert(actual);
     NSParameterAssert(expected);
     BOOL notLessThan = NO;
-    
+
     // NSValue category will throw an exception for invalid input(s)
     @try {
         notLessThan = [actual WOTest_testIsNotLessThanValue:expected];
@@ -1053,7 +1053,7 @@ jump_point:
 - (void)testNil:(void *)pointer inFile:(char *)path atLine:(int)line
 {
     BOOL result = (pointer ? NO : YES);
-    [self writePassed:result inFile:path atLine:line message:@"expected nil, got %@", 
+    [self writePassed:result inFile:path atLine:line message:@"expected nil, got %@",
         (result ? @"nil" : [NSString stringWithFormat:@"%x", pointer])];
 }
 
@@ -1079,10 +1079,10 @@ jump_point:
 #pragma mark -
 #pragma mark int test methods
 
-- (void)testIsInt:(char *)type inFile:(char *)path atLine:(int)line 
+- (void)testIsInt:(char *)type inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (strcmp(type, "i") == 0); 
-    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat: @"expected type \"i\", got \"%s\"", type]]; 
+    BOOL result = (strcmp(type, "i") == 0);
+    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat: @"expected type \"i\", got \"%s\"", type]];
 }
 
 - (void)testIsNotInt:(char *)type inFile:(char *)path atLine:(int)line
@@ -1114,64 +1114,64 @@ jump_point:
     [self testInt:aInt isNotEqualTo:(int)0 inFile:path atLine:line];
 }
 
-- (void)testInt:(int)actual isEqualTo:(int)expected inFile:(char *)path atLine:(int)line 
+- (void)testInt:(int)actual isEqualTo:(int)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual == expected); 
-    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat:@"expected %d, got %d", expected, actual]]; 
+    BOOL result = (actual == expected);
+    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat:@"expected %d, got %d", expected, actual]];
 }
 
-- (void)testInt:(int)actual isNotEqualTo:(int)expected inFile:(char *)path atLine:(int)line 
+- (void)testInt:(int)actual isNotEqualTo:(int)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual != expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected (not) %d, got %d", expected, actual]]; 
+    BOOL result = (actual != expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected (not) %d, got %d", expected, actual]];
 }
 
-- (void)testInt:(int)actual greaterThan:(int)expected inFile:(char *)path atLine:(int)line 
+- (void)testInt:(int)actual greaterThan:(int)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual > expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected > %d, got %d", expected, actual]]; 
+    BOOL result = (actual > expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected > %d, got %d", expected, actual]];
 }
 
-- (void)testInt:(int)actual notGreaterThan:(int)expected inFile:(char *)path atLine:(int)line 
+- (void)testInt:(int)actual notGreaterThan:(int)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual <= expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected <= %d, got %d", expected, actual]]; 
+    BOOL result = (actual <= expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected <= %d, got %d", expected, actual]];
 }
 
-- (void)testInt:(int)actual lessThan:(int)expected inFile:(char *)path atLine:(int)line 
+- (void)testInt:(int)actual lessThan:(int)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual < expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected < %d, got %d", expected, actual]]; 
+    BOOL result = (actual < expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected < %d, got %d", expected, actual]];
 }
 
-- (void)testInt:(int)actual notLessThan:(int)expected inFile:(char *)path atLine:(int)line 
+- (void)testInt:(int)actual notLessThan:(int)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual >= expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected >= %d, got %d", expected, actual]]; 
+    BOOL result = (actual >= expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected >= %d, got %d", expected, actual]];
 }
 
 #pragma mark -
 #pragma mark unsigned test methods
 
-- (void)testIsUnsigned:(char *)type inFile:(char *)path atLine:(int)line 
+- (void)testIsUnsigned:(char *)type inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (strcmp(type, "I") == 0); 
-    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat: @"expected type \"I\", got \"%s\"", type]]; 
+    BOOL result = (strcmp(type, "I") == 0);
+    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat: @"expected type \"I\", got \"%s\"", type]];
 }
 
 - (void)testIsNotUnsigned:(char *)type inFile:(char *)path atLine:(int)line
@@ -1183,68 +1183,68 @@ jump_point:
               message:[NSString stringWithFormat:@"expected type (not) \"I\", got \"%s\"", type]];
 }
 
-- (void)testUnsignedZero:(unsigned)aUnsigned inFile:(char *)path atLine:(int)line 
+- (void)testUnsignedZero:(unsigned)aUnsigned inFile:(char *)path atLine:(int)line
 {
-    return [self testUnsigned:aUnsigned isEqualTo:(unsigned)0 inFile:path atLine:line]; 
+    return [self testUnsigned:aUnsigned isEqualTo:(unsigned)0 inFile:path atLine:line];
 }
 
-- (void)testUnsignedNotZero:(unsigned)aUnsigned inFile:(char *)path atLine:(int)line 
+- (void)testUnsignedNotZero:(unsigned)aUnsigned inFile:(char *)path atLine:(int)line
 {
-    return [self testUnsigned:aUnsigned isNotEqualTo:(unsigned)0 inFile:path atLine:line]; 
+    return [self testUnsigned:aUnsigned isNotEqualTo:(unsigned)0 inFile:path atLine:line];
 }
 
 - (void)testUnsigned:(unsigned)actual isEqualTo:(unsigned)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual == expected);    
-    [self writePassed:result 
-               inFile:path 
+    BOOL result = (actual == expected);
+    [self writePassed:result
+               inFile:path
                atLine:line
               message:[NSString stringWithFormat:@"expected %u, got %u", expected, actual]];
 }
 
-- (void)testUnsigned:(unsigned)actual isNotEqualTo:(unsigned)expected inFile:(char *)path atLine:(int)line 
+- (void)testUnsigned:(unsigned)actual isNotEqualTo:(unsigned)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual != expected);    
-    [self writePassed:result 
-               inFile:path 
+    BOOL result = (actual != expected);
+    [self writePassed:result
+               inFile:path
                atLine:line
               message:[NSString stringWithFormat:@"expected (not) %u, got %u", expected, actual]];
 }
 
-- (void)testUnsigned:(unsigned)actual greaterThan:(unsigned)expected inFile:(char *)path atLine:(int)line 
+- (void)testUnsigned:(unsigned)actual greaterThan:(unsigned)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual > expected);    
-    [self writePassed:result 
-               inFile:path 
+    BOOL result = (actual > expected);
+    [self writePassed:result
+               inFile:path
                atLine:line
               message:[NSString stringWithFormat:@"expected > %u, got %u", expected, actual]];
 }
 
-- (void)testUnsigned:(unsigned)actual notGreaterThan:(unsigned)expected inFile:(char *)path atLine:(int)line 
+- (void)testUnsigned:(unsigned)actual notGreaterThan:(unsigned)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual <= expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected <= %u, got %u", expected, actual]]; 
+    BOOL result = (actual <= expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected <= %u, got %u", expected, actual]];
 }
 
-- (void)testUnsigned:(unsigned)actual lessThan:(unsigned)expected inFile:(char *)path atLine:(int)line 
+- (void)testUnsigned:(unsigned)actual lessThan:(unsigned)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual < expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected < %u, got %u", expected, actual]]; 
+    BOOL result = (actual < expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected < %u, got %u", expected, actual]];
 }
 
-- (void)testUnsigned:(unsigned)actual notLessThan:(unsigned)expected inFile:(char *)path atLine:(int)line 
+- (void)testUnsigned:(unsigned)actual notLessThan:(unsigned)expected inFile:(char *)path atLine:(int)line
 {
-    BOOL result = (actual >= expected); 
-    [self writePassed:result 
-               inFile:path 
-               atLine:line 
-              message:[NSString stringWithFormat:@"expected >= %u, got %u", expected, actual]]; 
+    BOOL result = (actual >= expected);
+    [self writePassed:result
+               inFile:path
+               atLine:line
+              message:[NSString stringWithFormat:@"expected >= %u, got %u", expected, actual]];
 }
 
 #pragma mark -
@@ -1253,7 +1253,7 @@ jump_point:
 - (void)testIsFloat:(char *)type inFile:(char *)path atLine:(int)line
 {
     BOOL result = (strcmp(type, "f") == 0);
-    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat: @"expected type \"f\", got \"%s\"", type]]; 
+    [self writePassed:result inFile:path atLine:line message:[NSString stringWithFormat: @"expected type \"f\", got \"%s\"", type]];
 }
 
 - (void)testIsNotFloat:(char *)type inFile:(char *)path atLine:(int)line
@@ -1265,94 +1265,94 @@ jump_point:
               message:[NSString stringWithFormat:@"expected type (not) \"f\", got \"%s\"", type]];
 }
 
-- (void)testFloatPositive:(float)aFloat inFile:(char *)path atLine:(int)line 
+- (void)testFloatPositive:(float)aFloat inFile:(char *)path atLine:(int)line
 {
-    return [self testFloat:aFloat greaterThan:(float)0.0 withinError:(float)0.0 inFile:path atLine:line]; 
+    return [self testFloat:aFloat greaterThan:(float)0.0 withinError:(float)0.0 inFile:path atLine:line];
 }
 
-- (void)testFloatNegative:(float)aFloat inFile:(char *)path atLine:(int)line 
+- (void)testFloatNegative:(float)aFloat inFile:(char *)path atLine:(int)line
 {
-    return [self testFloat:aFloat lessThan:(float)0.0 withinError:(float)0.0 inFile:path atLine:line]; 
+    return [self testFloat:aFloat lessThan:(float)0.0 withinError:(float)0.0 inFile:path atLine:line];
 }