NSValue+WOTest.h

   1 //
   2 //  NSValue+WOTest.h
   3 //  WOTest
   4 //
   5 //  Created by Wincent Colaiuta on 09 June 2005.
   6 //
   7 //  Copyright 2005-2007 Wincent Colaiuta.
   8 //  This program is free software: you can redistribute it and/or modify
   9 //  it under the terms of the GNU General Public License as published by
  10 //  the Free Software Foundation, either version 3 of the License, or
  11 //  (at your option) any later version.
  12 //
  13 //  This program is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 //  GNU General Public License for more details.
  17 //
  18 //  You should have received a copy of the GNU General Public License
  19 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 //
  21
  22 #import <Foundation/Foundation.h>
  23
  24 #import <objc/objc-class.h>
  25
  26 #ifndef _C_LNGLNG
  27
  28 /*! 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 */
  29 #define _C_LNGLNG 'q'
  30
  31 #endif
  32
  33 #ifndef _C_ULNGLNG
  34
  35 /*! 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 */
  36 #define _C_ULNGLNG 'Q'
  37
  38 #endif
  39
  40 #ifndef _C_99BOOL
  41
  42 /*! 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 */
  43 #define _C_99BOOL 'B'
  44
  45 #endif
  46
  47 /*! Macro that compares two scalar values, \p a and \p b, using standard relational operators and returns NSOrderedSame, NSOrderedAscending or NSOrderedDescending. */
  48 #define WO_COMPARE_SCALARS(a, b) \
  49 ((a) == (b) ? NSOrderedSame : ((a) < (b) ? NSOrderedAscending : NSOrderedDescending))
  50
  51 /*! This category adds unit testing methods to the NSValue class. It provides methods for comparing NSValue objects for equality/non-equality and ordering.
  52
  53 The base NSValue class adopts a stricter view of equality that makes it hard to compare numeric scalar values (char, int, short, long, long long, unsigned char, unsigned int, unsigned short, unsigned long, unsigned long long, float, double and C99 _Bool) because those values must be of the same type or class. For example, an NSValue that contains an int (10) and another that contains a long (10) would be considered unequal according the default implementation of the isEqualTo: method because they are not of the same type. Likewise an NSValue containing an NSMutableString (@"string") and another containing an NSString (@"string") would also be considered unequal because they are of different classes.
  54
  55 This category adds a number of high-level methods for use in unit testing that implement a more flexible comparison method. Any numeric scalar value can be compared to any other scalar value and the values will be appropriately cast before comparison. In cases where GCC would issue a warning (for example, when comparing a signed and an unsigned type) a warning will be printed to the console (and will appear in the Xcode build results).
  56
  57 Any object can be compared to any other object for equality provided that it implements the isEqualTo: method. If it does not implement the method then the WOTest_testIsEqualToValue: method will return NO. If both ids are nil then the method returns YES.
  58
  59 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.
  60
  61 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. */
  62 @interface NSValue (WOTest)
  63
  64 #pragma mark -
  65 #pragma mark Value creation methods
  66
  67 + (NSValue *)WOTest_valueWithChar:(char)aChar;
  68
  69 + (NSValue *)WOTest_valueWithInt:(int)anInt;
  70
  71 + (NSValue *)WOTest_valueWithShort:(short)aShort;
  72
  73 + (NSValue *)WOTest_valueWithLong:(long)aLong;
  74
  75 + (NSValue *)WOTest_valueWithLongLong:(long long)aLongLong;
  76
  77 + (NSValue *)WOTest_valueWithUnsignedChar:(unsigned char)anUnsignedChar;
  78
  79 + (NSValue *)WOTest_valueWithUnsignedInt:(unsigned int)anUnsignedInt;
  80
  81 + (NSValue *)WOTest_valueWithUnsignedShort:(unsigned short)anUnsignedShort;
  82
  83 + (NSValue *)WOTest_valueWithUnsignedLong:(unsigned long)anUnsignedLong;
  84
  85 + (NSValue *)WOTest_valueWithUnsignedLongLong:(unsigned long long)anUnsignedLongLong;
  86
  87 + (NSValue *)WOTest_valueWithFloat:(float)aFloat;
  88
  89 + (NSValue *)WOTest_valueWithDouble:(double)aDouble;
  90
  91 + (NSValue *)WOTest_valueWithC99Bool:(_Bool)aC99Bool;
  92
  93 + (NSValue *)WOTest_valueWithConstantCharacterString:(const char *)aConstantCharString;
  94
  95 + (NSValue *)WOTest_valueWithCharacterString:(char *)aCharacterString;
  96
  97 /*! Unlike Cocoa's valueWithNonretainedObject method, which is equivalent to calling:
  98
  99     \code
 100     NSValue *theValue = [NSValue value:&anObject withObjCType:@encode(void  *)];
 101     \endcode
 102
 103                                                This method is equivalent to invoking:
 104
 105     \code
 106     NSValue *theValue = [NSValue value:&anObject withObjCType:@encode(id)];
 107     \endcode
 108
 109     The object is not retained.
 110
 111     */
 112 + (NSValue *)WOTest_valueWithObject:(id)anObject;
 113
 114 + (NSValue *)WOTest_valueWithClass:(Class)aClass;
 115
 116 + (NSValue *)WOTest_valueWithSelector:(SEL)aSelector;
 117
 118 #pragma mark -
 119 #pragma mark Parsing type strings
 120
 121 /*!
 122 \name Parsing type strings
 123 \startgroup
 124 */
 125
 126 /*! Used to determine the maximum number of bytes needed to store the type represented by \p typeString when it is embedded inside a composite type (a struct, array or union). It is possible that compiler pragmas or flags may lead to data being aligned differently and packed in a more compact form, but this method is guaranteed to return the maximum amount of space that would be required to store the type under the least-compact alignment conditions. The alignments and embedding rules are taken from "The alignments taken from Apple's "Mac OS X ABI Function Call Guide". Throws an exception if \p typeString is nil. */
 127 + (size_t)WOTest_maximumEmbeddedSizeForType:(NSString *)typeString;
 128
 129 /*! This method returns the minimum buffer size required to safely store an object of the type represented by \p typeString. Because it is impossible to know if any compiler pragmas or flags were used to change the default alignment behaviour of composite  types (structs, arrays, unions), this method bases its calculations on the space that would be required if the least-packed alignment were chosen. As such the values returned by this function may be greater than or equal to those returned by the sizeof compiler directive, but never less than. Throws an exception if \p typeString is nil. */
 130 + (size_t)WOTest_sizeForType:(NSString *)typeString;
 131
 132 /*! 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). */
 133 + (BOOL)WOTest_typeIsNumericScalar:(NSString *)typeString;
 134
 135 /*! Returns YES if \p typeString represents a compound type (struct, union or array). */
 136 + (BOOL)WOTest_typeIsCompound:(NSString *)typeString;
 137
 138 + (BOOL)WOTest_typeIsChar:(NSString *)typeString;
 139
 140 + (BOOL)WOTest_typeIsInt:(NSString *)typeString;
 141
 142 + (BOOL)WOTest_typeIsShort:(NSString *)typeString;
 143
 144 + (BOOL)WOTest_typeIsLong:(NSString *)typeString;
 145
 146 + (BOOL)WOTest_typeIsLongLong:(NSString *)typeString;
 147
 148 + (BOOL)WOTest_typeIsUnsignedChar:(NSString *)typeString;
 149
 150 + (BOOL)WOTest_typeIsUnsignedInt:(NSString *)typeString;
 151
 152 + (BOOL)WOTest_typeIsUnsignedShort:(NSString *)typeString;
 153
 154 + (BOOL)WOTest_typeIsUnsignedLong:(NSString *)typeString;
 155
 156 + (BOOL)WOTest_typeIsUnsignedLongLong:(NSString *)typeString;
 157
 158 + (BOOL)WOTest_typeIsFloat:(NSString *)typeString;
 159
 160 + (BOOL)WOTest_typeIsDouble:(NSString *)typeString;
 161
 162 + (BOOL)WOTest_typeIsC99Bool:(NSString *)typeString;
 163
 164 + (BOOL)WOTest_typeIsVoid:(NSString *)typeString;
 165
 166 + (BOOL)WOTest_typeIsConstantCharacterString:(NSString *)typeString;
 167
 168 + (BOOL)WOTest_typeIsCharacterString:(NSString *)typeString;
 169
 170 + (BOOL)WOTest_typeIsObject:(NSString *)typeString;
 171
 172 + (BOOL)WOTest_typeIsClass:(NSString *)typeString;
 173
 174 + (BOOL)WOTest_typeIsSelector:(NSString *)typeString;
 175
 176 + (BOOL)WOTest_typeIsPointerToVoid:(NSString *)typeString;
 177
 178 + (BOOL)WOTest_typeIsPointer:(NSString *)typeString;
 179
 180 + (BOOL)WOTest_typeIsArray:(NSString *)typeString;
 181
 182 + (BOOL)WOTest_typeIsStruct:(NSString *)typeString;
 183
 184 + (BOOL)WOTest_typeIsUnion:(NSString *)typeString;
 185
 186 + (BOOL)WOTest_typeIsBitfield:(NSString *)typeString;
 187
 188 + (BOOL)WOTest_typeIsUnknown:(NSString *)typeString;
 189
 190 /*! \endgroup */
 191
 192 #pragma mark -
 193 #pragma mark High-level test methods
 194
 195 /*!
 196 \name High-level test methods
 197 \startgroup
 198 */
 199
 200 /*! Compares the receiver with \p aValue for equality and returns YES if equal, NO otherwise. When both the receiver and \p aValue are objects tries to send an isEqualTo: message to the receiver; if the receiver does not implement that selector then the default NSValue isEqualToValue: method is invoked. When both the receiver and \p aValue represent numeric scalars casting is performed as already described. There is one special case where an object to numeric scalar comparison is permitted and that is when the numeric value is both the same size and value as a nil pointer (in other words an int with value 0), such as the relatively common case in which the caller might try to compare an object to nil (in this case the C preprocessor will have substituted "0" for "nil" which means that the NSValue object will record it as an representing an integer rather than an id). This special case is necessary so that test macros such as the following work as expected:
 201
 202 \code
 203 WO_TEST_EQUAL(nil, theObject);          // looks like comparing an id with an id
 204 WO_TEST_NOT_EQUAL(otherObject, nil);    // looks like comparing an id with an id
 205
 206 // which are equivalent to:
 207 WO_TEST_EQUAL(0, theObject);            // actually comparing an int with an id
 208 WO_TEST_NOT_EQUAL(otherObject, 0);      // actually comparing an id with an int
 209 \endcode
 210
 211 Note that the following example would work even without this special handling because in this case there is enough information present at compile time to prevent the nil value from being interpreted as an int:
 212
 213 \code
 214 NSString *aString = nil;
 215 WO_TEST_EQUAL(aString, otherString);    // comparing an id with and id
 216 \endcode
 217
 218 Special case handling notwithstanding, attempting to compare a non-zero int with an object will raise an exception:
 219
 220 \code
 221 WO_TEST_EQUAL(25, aString);             // raises
 222 \endcode
 223
 224 In all other cases the default NSValue isEqualToValue: method is used as a fallback.
 225
 226 <table>
 227 <tr>
 228 <td>Compare value:</td>
 229 <td>With value:</td>
 230 <td>Result:</td>
 231 </tr>
 232 <tr>
 233 <td>numeric scalar</td>
 234 <td>numeric scalar</td>
 235 <td>automated casting takes place prior to comparison, warning printed to console at runtime if risky casts are required (for example signed and unsigned) </td>
 236 </tr>
 237 <tr>
 238 <td>id</td>
 239 <td>id</td>
 240 <td>compared using isEqual: if right-handle value implements that method, otherwise default NSValue isEqualToValue: behaviour used </td>
 241 </tr>
 242 <tr>
 243 <td>id</td>
 244 <td>numeric scalar</td>
 245 <td>comparison allowed if and only if the numeric scalar value is equivalent to "nil", otherwise throws exception </td>
 246 </tr>
 247 <tr>
 248 <td>numeric scalar</td>
 249 <td>id</td>
 250 <td>comparison allowed if and only if the numeric scalar value is equivalent to "nil", otherwise throws exception </td>
 251 </tr>
 252 <tr>
 253 <td>void * </td>
 254 <td>numeric scalar </td>
 255 <td>comparison allowed if and only if the numeric scalar value is equivalent to "nil", otherwise throws exception </td>
 256 </tr>
 257 <tr>
 258 <td>numeric scalar </td>
 259 <td>void * </td>
 260 <td>comparison allowed if any only if the numeric scalar value is equivalent to "nil", otherwise throws exception </td>
 261 </tr>
 262 <tr>
 263 <td>char*</td>
 264 <td>char[]</td>
 265 <td>if possible creates NSString representations of the two values and compares them; if comparison not possible falls back to default NSValue isEqualToValue: behaviour</td>
 266 </tr>
 267 <tr>
 268 <td>char[]</td>
 269 <td>char * </td>
 270 <td>if possible creates NSString representations of the two values and compares them; if comparison not possible falls back to default NSValue isEqualToValue: behaviour</td>
 271 </tr>
 272 <tr>
 273 <td>const char* </td>
 274 <td>char[]</td>
 275 <td>if possible creates NSString representations of the two values and compares them; if comparison not possible falls back to default NSValue isEqualToValue: behaviour</td>
 276 </tr>
 277 <tr>
 278 <td>char[]</td>
 279 <td>const char* </td>
 280 <td>if possible creates NSString representations of the two values and compares them; if comparison not possible falls back to default NSValue isEqualToValue: behaviour</td>
 281 </tr>
 282 </table>
 283
 284 */
 285 - (BOOL)WOTest_testIsEqualToValue:(NSValue *)aValue;
 286
 287 // TODO: write tests that make use of these methods? so far only use the isEqual variant
 288 - (BOOL)WOTest_testIsGreaterThanValue:(NSValue *)aValue;
 289
 290 - (BOOL)WOTest_testIsLessThanValue:(NSValue *)aValue;
 291
 292 - (BOOL)WOTest_testIsNotGreaterThanValue:(NSValue *)aValue;
 293
 294 - (BOOL)WOTest_testIsNotLessThanValue:(NSValue *)aValue;
 295
 296 /*! The table below indicates the warnings that GCC issues when trying to compare numeric scalars of different types. "-" indicates that no warning is issued and the compiler performs an implicit cast. "W" indicates that the compiler issues a warning about signed/unsigned comparison; in this case WOTest performs an explicit cast and prints a warning to the console (visible in the Xcode build results window) at runtime.
 297
 298 <table>
 299   <tr>
 300     <td>type</td>
 301     <td>char</td>
 302     <td>int</td>
 303     <td>short</td>
 304     <td>long</td>
 305     <td>long long </td>
 306     <td>unsigned char </td>
 307     <td>unsigned int</td>
 308     <td>unsigned short </td>
 309     <td>unsigned long </td>
 310     <td>unsigned long long </td>
 311     <td>float</td>
 312     <td>double</td>
 313     <td>C99 _Bool </td>
 314   </tr>
 315   <tr>
 316     <td>char</td>
 317     <td>-</td>
 318     <td>-</td>
 319     <td>-</td>
 320     <td>-</td>
 321     <td>-</td>
 322     <td>-</td>
 323     <td>W</td>
 324     <td>-</td>
 325     <td>W</td>
 326     <td>W</td>
 327     <td>-</td>
 328     <td>-</td>
 329     <td>-</td>
 330   </tr>
 331   <tr>
 332     <td>int</td>
 333     <td>-</td>
 334     <td>-</td>
 335     <td>-</td>
 336     <td>-</td>
 337     <td>-</td>
 338     <td>-</td>
 339     <td>W</td>
 340     <td>-</td>
 341     <td>W</td>
 342     <td>W</td>
 343     <td>-</td>
 344     <td>-</td>
 345     <td>-</td>
 346   </tr>
 347   <tr>
 348     <td>short</td>
 349     <td>-</td>
 350     <td>-</td>
 351     <td>-</td>
 352     <td>-</td>
 353     <td>-</td>
 354     <td>-</td>
 355     <td>W</td>
 356     <td>-</td>
 357     <td>W</td>
 358     <td>W</td>
 359     <td>-</td>
 360     <td>-</td>
 361     <td>-</td>
 362   </tr>
 363   <tr>
 364     <td>long</td>
 365     <td>-</td>
 366     <td>-</td>
 367     <td>-</td>
 368     <td>-</td>
 369     <td>-</td>
 370     <td>-</td>
 371     <td>W</td>
 372     <td>-</td>
 373     <td>W</td>
 374     <td>W</td>
 375     <td>-</td>
 376     <td>-</td>
 377     <td>-</td>
 378   </tr>
 379   <tr>
 380     <td>long long </td>
 381     <td>-</td>
 382     <td>-</td>
 383     <td>-</td>
 384     <td>-</td>
 385     <td>-</td>
 386     <td>-</td>
 387     <td>-</td>
 388     <td>-</td>
 389     <td>-</td>
 390     <td>W</td>
 391     <td>-</td>
 392     <td>-</td>
 393     <td>-</td>
 394   </tr>
 395   <tr>
 396     <td>unsigned char </td>
 397     <td>-</td>
 398     <td>-</td>
 399     <td>-</td>
 400     <td>-</td>
 401     <td>-</td>
 402     <td>-</td>
 403     <td>-</td>
 404     <td>-</td>
 405     <td>-</td>
 406     <td>-</td>
 407     <td>-</td>
 408     <td>-</td>
 409     <td>-</td>
 410   </tr>
 411   <tr>
 412     <td>unsigned int </td>
 413     <td>W</td>
 414     <td>W</td>
 415     <td>W</td>
 416     <td>W</td>
 417     <td>-</td>
 418     <td>-</td>
 419     <td>-</td>
 420     <td>-</td>
 421     <td>-</td>
 422     <td>-</td>
 423     <td>-</td>
 424     <td>-</td>
 425     <td>-</td>
 426   </tr>
 427   <tr>
 428     <td>unsigned short </td>
 429     <td>-</td>
 430     <td>-</td>
 431     <td>-</td>
 432     <td>-</td>
 433     <td>-</td>
 434     <td>-</td>
 435     <td>-</td>
 436     <td>-</td>
 437     <td>-</td>
 438     <td>-</td>
 439     <td>-</td>
 440     <td>-</td>
 441     <td>-</td>
 442   </tr>
 443   <tr>
 444     <td>unsigned long </td>
 445     <td>W</td>
 446     <td>W</td>
 447     <td>W</td>
 448     <td>W</td>
 449     <td>-</td>
 450     <td>-</td>
 451     <td>-</td>
 452     <td>-</td>
 453     <td>-</td>
 454     <td>-</td>
 455     <td>-</td>
 456     <td>-</td>
 457     <td>-</td>
 458   </tr>
 459   <tr>
 460     <td>unsigned long long </td>
 461     <td>W</td>
 462     <td>W</td>
 463     <td>W</td>
 464     <td>W</td>
 465     <td>W</td>
 466     <td>-</td>
 467     <td>-</td>
 468     <td>-</td>
 469     <td>-</td>
 470     <td>-</td>
 471     <td>-</td>
 472     <td>-</td>
 473     <td>-</td>
 474   </tr>
 475   <tr>
 476     <td>float</td>
 477     <td>-</td>
 478     <td>-</td>
 479     <td>-</td>
 480     <td>-</td>
 481     <td>-</td>
 482     <td>-</td>
 483     <td>-</td>
 484     <td>-</td>
 485     <td>-</td>
 486     <td>-</td>
 487     <td>-</td>
 488     <td>-</td>
 489     <td>-</td>
 490   </tr>
 491   <tr>
 492     <td>double</td>
 493     <td>-</td>
 494     <td>-</td>
 495     <td>-</td>
 496     <td>-</td>
 497     <td>-</td>
 498     <td>-</td>
 499     <td>-</td>
 500     <td>-</td>
 501     <td>-</td>
 502     <td>-</td>
 503     <td>-</td>
 504     <td>-</td>
 505     <td>-</td>
 506   </tr>
 507   <tr>
 508     <td>C99 _Bool</td>
 509     <td>-</td>
 510     <td>-</td>
 511     <td>-</td>
 512     <td>-</td>
 513     <td>-</td>
 514     <td>-</td>
 515     <td>-</td>
 516     <td>-</td>
 517     <td>-</td>
 518     <td>-</td>
 519     <td>-</td>
 520     <td>-</td>
 521     <td>-</td>
 522   </tr>
 523 </table>
 524
 525 Table corresponds to the warnings produced by the version of GCC 4.0 that ships with Apple's Xcode 2.1, "powerpc-apple-darwin8-gcc-4.0.0 (GCC) 4.0.0 (Apple Computer, Inc. build 5026)". */
 526 - (NSComparisonResult)WOTest_compare:(NSValue *)aValue;
 527
 528 /*! \endgroup */
 529
 530 #pragma mark -
 531 #pragma mark Utility methods
 532
 533 //! \name Utility methods
 534 //! \startgroup
 535
 536 //! Returns the buffer size necessary to hold the contents of the receiver. For use in conjunction with the getValue method.
 537 - (size_t)WOTest_bufferSize;
 538
 539 //! Prints a warning to the console about a signed-to-unsigned comparison together with information about the last known location (file and line).
 540 - (void)WOTest_printSignCompareWarning:(NSString *)warning;
 541
 542 //! \endgroup
 543
 544 #pragma mark -
 545 #pragma mark Convenience methods
 546
 547 /*!
 548 \name Convenience methods
 549 \startgroup
 550 */
 551
 552 /*! Returns the Objective-C type of the receiver as an NSString. */
 553 - (NSString *)WOTest_objCTypeString;
 554
 555 /*! Returns a human-readable description of the receiver. */
 556 - (NSString *)WOTest_description;
 557
 558 /*! \endgroup */
 559
 560 #pragma mark -
 561 #pragma mark Identifying generic types
 562
 563 /*!
 564 \name Identifying generic types
 565 \startgroup
 566 */
 567
 568 /*! Returns YES if the receiver 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). */
 569 - (BOOL)WOTest_isNumericScalar;
 570
 571 - (BOOL)WOTest_isPointer;
 572
 573 - (BOOL)WOTest_isArray;
 574
 575 /*! Returns the count of items in the array stored by the receiver. Raises an exception if the receiver does not store an array. */
 576 - (unsigned)WOTest_arrayCount;
 577
 578 /*! Returns the type string of the elements in the array stored by the receiver. Raises an exception if the receiver does not store an array. */
 579 - (NSString *)WOTest_arrayType;
 580
 581 - (BOOL)WOTest_isStruct;
 582
 583 - (BOOL)WOTest_isUnion;
 584
 585 - (BOOL)WOTest_isBitfield;
 586
 587 /*! True if the receiver contains a value of type "unknown" (indicated by "?"). Function pointers, for example, are encoded with this type by the \@encode() compiler directive. */
 588 - (BOOL)WOTest_isUnknown;
 589
 590 /*! \endgroup */
 591
 592 #pragma mark -
 593 #pragma mark Identifying and retrieving specific types
 594
 595 /*!
 596 \name Identifying and retrieving specific types
 597 \startgroup
 598 */
 599
 600 /*! Returns YES if the receiver contains a char. */
 601 - (BOOL)WOTest_isChar;
 602
 603 /*! Returns YES if the receiver contains an int. */
 604 - (BOOL)WOTest_isInt;
 605
 606 /*! Returns YES if the receiver contains a short. */
 607 - (BOOL)WOTest_isShort;
 608
 609 /*! Returns YES if the receiver contains a long. */
 610 - (BOOL)WOTest_isLong;
 611
 612 /*! Returns YES if the receiver contains a long long. */
 613 - (BOOL)WOTest_isLongLong;
 614
 615 /*! Returns YES if the receiver contains an unsigned char. */
 616 - (BOOL)WOTest_isUnsignedChar;
 617
 618 /*! Returns YES if the receiver contains an unsigned int. */
 619 - (BOOL)WOTest_isUnsignedInt;
 620
 621 /*! Returns YES if the receiver contains an unsigned short. */
 622 - (BOOL)WOTest_isUnsignedShort;
 623
 624 /*! Returns YES if the receiver contains an unsigned long. */
 625 - (BOOL)WOTest_isUnsignedLong;
 626
 627 /*! Returns YES if the receiver contains an unsigned long long. */
 628 - (BOOL)WOTest_isUnsignedLongLong;
 629
 630 /*! Returns YES if the receiver contains a float. */
 631 - (BOOL)WOTest_isFloat;
 632
 633 /*! Returns YES if the receiver contains a double. */
 634 - (BOOL)WOTest_isDouble;
 635
 636 /*! Returns YES if the receiver contains a C99 _Bool. */
 637 - (BOOL)WOTest_isC99Bool;
 638
 639 /*! Returns YES if the receiver contains a void. */
 640 - (BOOL)WOTest_isVoid;
 641
 642 /*! Returns YES if the receiver contains a constant character string (const char *). */
 643 - (BOOL)WOTest_isConstantCharacterString;
 644
 645 /*! Returns YES if the receiver contains a character string (char *). */
 646 - (BOOL)WOTest_isCharacterString;
 647
 648 /*! Returns YES if the receiver contains an (id or statically typed) object. */
 649 - (BOOL)WOTest_isObject;
 650
 651 /*! Returns YES if the receiver contains a Class object. */
 652 - (BOOL)WOTest_isClass;
 653
 654 /*! Returns YES if the receiver contains a method selector (SEL). */
 655 - (BOOL)WOTest_isSelector;
 656
 657 /*! Returns YES if the receiver contains a pointer to void. */
 658 - (BOOL)WOTest_isPointerToVoid;
 659
 660 /*! If the receiver was created to hold a char-sized data item, returns that item as a char. Otherwise, the result is undefined. */
 661 - (char)WOTest_charValue;
 662
 663 /*! If the receiver was created to hold an int-sized data item, returns that item as an int. Otherwise, the result is undefined. */
 664 - (int)WOTest_intValue;
 665
 666 /*! If the receiver was created to hold a short-sized data item, returns that item as a short. Otherwise, the result is undefined. */
 667 - (short)WOTest_shortValue;
 668
 669 /*! If the receiver was created to hold a long-sized data item, returns that item as a long. Otherwise, the result is undefined. */
 670 - (long)WOTest_longValue;
 671
 672 /*! If the receiver was created to hold a long long-sized data item, returns that item as a long long. Otherwise, the result is undefined. */
 673 - (long long)WOTest_longLongValue;
 674
 675 /*! If the receiver was created to hold an unsigned char-sized data item, returns that item as an unsigned char. Otherwise, the result is undefined. */
 676 - (unsigned char)WOTest_unsignedCharValue;
 677
 678 /*! If the receiver was created to hold an unsigned int-sized data item, returns that item as an unsigned int. Otherwise, the result is undefined. */
 679 - (unsigned int)WOTest_unsignedIntValue;
 680
 681 /*! If the receiver was created to hold an unsigned short-sized data item, returns that item as an unsigned short. Otherwise, the result is undefined. */
 682 - (unsigned short)WOTest_unsignedShortValue;
 683
 684 /*! If the receiver was created to hold an unsigned long-sized data item, returns that item as an unsigned long. Otherwise, the result is undefined. */
 685 - (unsigned long)WOTest_unsignedLongValue;
 686
 687 /*! If the receiver was created to hold an unsigned long long-sized data item, returns that item as an unsigned long long. Otherwise, the result is undefined. */
 688 - (unsigned long long)WOTest_unsignedLongLongValue;
 689
 690 /*! If the receiver was created to hold a float-sized data item, returns that item as a float. Otherwise, the result is undefined. */
 691 - (float)WOTest_floatValue;
 692
 693 /*! If the receiver was created to hold a double-sized data item, returns that item as a double. Otherwise, the result is undefined. */
 694 - (double)WOTest_doubleValue;
 695
 696 /*! If the receiver was created to hold a C99 _Bool-sized data item, returns that item as a C99 _Bool. Otherwise, the result is undefined. */
 697 - (_Bool)WOTest_C99BoolValue;
 698
 699 /*! If the receiver was created to hold a constant character string-sized data item, returns that item as a constant character string. Otherwise, the result is undefined. */
 700 - (const char *)WOTest_constantCharacterStringValue;
 701
 702 /*! If the receiver was created to hold a character string-sized data item, returns that item as a character string. Otherwise, the result is undefined. */
 703 - (char *)WOTest_characterStringValue;
 704
 705 /*! If the receiver was created to hold an id-sized data item, returns that item as an id. Otherwise, the result is undefined. */
 706 - (id)WOTest_objectValue;
 707
 708 /*! If the receiver was created to hold a Class-sized data item, returns that item as a Class. Otherwise, the result is undefined. */
 709 - (Class)WOTest_classValue;
 710
 711 /*! If the receiver was created to hold a SEL-sized data item, returns that item as a SEL. Otherwise, the result is undefined. */
 712 - (SEL)WOTest_selectorValue;
 713
 714 - (void *)WOTest_pointerToVoidValue;
 715
 716 /*! Returns YES if the receiver is an array of characters (of type char). This method looks for encoding strings of the form "[1c]", "[2c]", "[3c]" and so forth. There are no guarantees that such arrays are null-terminated. Such encodings are produced when passing constant strings to the WOTest macros as illustrated below:
 717
 718 \code
 719 WO_TEST_NOT_EQUAL("foo", "bar");
 720 \endcode
 721
 722 When encoded as NSValues the two constant strings in the example above would be encoded as having type "[4c]" (3 chars plus a terminating byte). */
 723 - (BOOL)WOTest_isCharArray;
 724
 725 /*! If WOTest_isCharacterString returns YES then this method attempts to return an NSString representation of the content of the receiver; returns nil if no representation could be produced. If WOTest_isCharArray returns YES then attempts to do the same, returning nil if not possible. */
 726 - (NSString *)WOTest_stringValue;
 727
 728 /*! \endgroup */
 729
 730 #pragma mark -
 731 #pragma mark Low-level test methods
 732
 733 /*!
 734 \name Low-level test methods
 735 \startgroup
 736 */
 737
 738 - (NSComparisonResult)WOTest_compareWithChar:(char)other;
 739
 740 - (NSComparisonResult)WOTest_compareWithInt:(int)other;
 741
 742 - (NSComparisonResult)WOTest_compareWithShort:(short)other;
 743
 744 - (NSComparisonResult)WOTest_compareWithLong:(long)other;
 745
 746 - (NSComparisonResult)WOTest_compareWithLongLong:(long long)other;
 747
 748 - (NSComparisonResult)WOTest_compareWithUnsignedChar:(unsigned char)other;
 749
 750 - (NSComparisonResult)WOTest_compareWithUnsignedInt:(unsigned int)other;
 751
 752 - (NSComparisonResult)WOTest_compareWithUnsignedShort:(unsigned short)other;
 753
 754 - (NSComparisonResult)WOTest_compareWithUnsignedLong:(unsigned long)other;
 755
 756 - (NSComparisonResult)WOTest_compareWithUnsignedLongLong:(unsigned long long)other;
 757
 758 - (NSComparisonResult)WOTest_compareWithFloat:(float)other;
 759
 760 - (NSComparisonResult)WOTest_compareWithDouble:(double)other;
 761
 762 - (NSComparisonResult)WOTest_compareWithC99Bool:(_Bool)other;
 763
 764 /*! \endgroup */
 765
 766 @end