-: 0:Source:ZIP/mnyfmtts.c -: 0:Graph:mnyfmtts.gcno -: 0:Data:mnyfmtts.gcda -: 0:Runs:1 -: 0:Programs:1 -: 1:// (C) Copyright Adolfo Di Mare 2011 -: 2:// Use, modification and distribution are subject to the -: 3:// Boost Software License, Version 1.0. -: 4:// (See accompanying file LICENSE_1_0.txt or copy at -: 5:// http://www.boost.org/LICENSE_1_0.txt) -: 6: -: 7:// Revision history: -: 8:// 11 Oct 2011 Adolfo Di Mare -: 9:// Initial (non boost) version -: 10: -: 11:// mnyfmtts.c (C) 2011 adolfo@di-mare.com -: 12: -: 13:// Test file for mnyfmt() -: 14:// - Works with Borland C++ 3.1 (1992) -: 15:// - Works with Code::Blocks 10.05 (2010) -: 16: -: 17:/** \file mnyfmtts.c -: 18: \brief Test program for \c mnyfmt(). -: 19: -: 20: \author Adolfo Di Mare -: 21: \date 2011 -: 22:*/ -: 23: -: 24:// Define this macro if your compiler does not have a (long long) data type -: 25:// #define MNYFMT_NO_LONG_LONG -: 26:#include "mnyfmt.h" -: 27: -: 28:// This works in the Borland C++ 3.1 IDE -: 29:// Alt-Options -> Compiler -> Code generation... -: 30:// -> Defines MNYFMT_NO_LONG_LONG -: 31: -: 32:#ifdef __cplusplus -: 33:// To compile the C source using the C++ compiler, override the file's extension. -: 34:// The GNU gcc compiler does this with option -x: gcc -x c++ -: 35:// - http://google.com/search?as_qdr=all&num=100&as_q=mix+c+c%2B%2B -: 36:#endif -: 37: -: 38:#include "uUnit.h" // assertTrue()+assertFalse() -: 39:#include // malloc() && free() -: 40:#include // printf() -: 41:#include // strcpy() strlen() etc. -: 42:#include // modf() -: 43:#include // LONG_MAX -: 44: -: 45:#if 0 -: 46: #ifndef __cplusplus -: 47: // namespace polution ??? -: 48: #define mnyfmt( a,b,c,d) mnyfmt(a,b,c,d) -: 49: #define format_money(a,b,c,d) mnyfmt(a,b,c,d) -: 50: #else -: 51: #define mnyfmt( a,b,c,d) mnyfmt(a,b,c,d) -: 52: #define format_money(a,b,c,d) mnyfmt(a,b,c,d) -: 53: #endif -: 54:#endif -: 55: -: 56:/// Ensure that, at least for this test program [mnyfmtts.c], -: 57:/// the formatting \c char is digit \c '9'. -: 58:typedef char mnyfmtts_REQUIRES_mnyfmt_format_char_EQUAL_TO_digit_9 -: 59: [ (mnyfmt_format_char=='9' ? 1 :-1 ) ]; -: 60: -: 61:/// s1 == s2 ??? 89: 62:int eqstr(const char *s1, const char *s2) { 89: 62-block 0 -: 63: #ifndef __cplusplus 89: 64: const int false = 0; const int true = !false; -: 65: #endif 89: 66: if (s1==0 && s2==0) { return true; } 89: 66-block 0 $$$$$: 66-block 1 $$$$$: 66-block 2 89: 67: if (s1==0 || s2==0) { return false; } 89: 67-block 0 89: 67-block 1 $$$$$: 67-block 2 89: 68: return (strcmp(s1,s2) == 0) ? true : false; 89: 68-block 0 81: 68-block 1 8: 68-block 2 89: 68-block 3 -: 69:} -: 70: -: 71:/// Used by 'mnyfmt_wrap()' to check for memory overwrites -: 72:typedef struct { -: 73: char *sgn; ///< Returned by mnyfmt() -: 74: char before [128]; ///< Filler before str[] -: 75: char str [256]; ///< Format string for mnyfmt() -: 76: char after [128]; ///< Filler after str[] -: 77:} FMTSTR; -: 78: -: 79:/// Wrapper around 'mnyfmt()' to check that it does not overwrite adyacent memory 57: 80:char* mnyfmt_wrap( char *format, char dec, mnyfmt_long intpart, unsigned CE) { 57: 80-block 0 57: 81: char fill[] = { '!', (char)(0xf0) , 0x0f, 0x8, 2 , 0 }; -: 82: FMTSTR fmtstr[ (sizeof(fill)/sizeof(*fill)) ]; -: 83: unsigned i,dim, len; -: 84: -: 85: // handle the null pointer as argument case 113: 86: if (!format) { return mnyfmt( (char*)(0), dec, intpart,CE ); } 57: 86-block 0 1: 86-block 1 1: 86-block 2 57: 86-block 3 57: 86-block 4 -: 87: 56: 88: dim = (sizeof(fill)/sizeof(*fill)); 56: 89: len = strlen(format); 56: 90: if (len >= sizeof(fmtstr[0].str) ) { return 0; } 56: 90-block 0 $$$$$: 90-block 1 314: 91: for ( i=0; i[%s]\n", #x, x ); } while(0) -: 146:/// Abreviation to invoke show(fmtstr) -: 147:#define sh show(fmtstr); -: 148: -: 149:/// test ==> mnyfmt() 1: 150:int mnyfmtts( const int argc , const char* argv[] ) { 1: 150-block 0 -: 151:{{ // test.example -: 152: // (2^128 < 10^40) && (2*40<96) ==> char[96] holds a -: 153: char *sgn, fmtstr[96],mem[96]; // 128 bit integer -: 154: -: 155: unsigned CE, ten_pow_CE; 1: 156: CE = 2; ten_pow_CE = 100; // 10^CE -> "Currency Exponent" -: 157: 1: 158: strcpy( mem, "USD$ " ); // Picture clause 1: 159: strcpy( fmtstr , "99,999,999.99999" ); 1: 160: if (( sgn = mnyfmt( fmtstr , '.' ,-10245587,CE ) )) { 1: 160-block 0 1: 160-block 1 1: 161: assertTrue( eqstr( fmtstr , "0-,102,455.87000") ); 1: 161-block 0 1: 161-block 1 1: 162: if ( (*sgn=='-') && (','==*(sgn+1)) ) { ++sgn; *sgn='-'; } 1: 162-block 0 1: 162-block 1 1: 162-block 2 1: 163: assertTrue( eqstr( sgn, "-102,455.87000") ); 1: 163-block 0 1: 163-block 1 -: 164: 1: 165: strcat( mem , sgn ); 1: 166: assertTrue( eqstr( mem, "USD$ -102,455.87000") ); 1: 166-block 0 1: 166-block 1 1: 166-block 2 -: 167: } -: 168: else { #####: 169: assertFalse( "ERROR [???]: " "-102,455.87000" ); $$$$$: 169-block 0 -: 170: } -: 171:}} -: 172: -: 173:{{ // test.neg.comma -: 174: // (2^128 < 10^40) && (2*40<96) ==> char[96] holds a -: 175: char *sgn, fmtstr[96]; // 128 bit integer -: 176: 1: 177: strcpy( fmtstr , "9,999,999.99" ); 1: 178: if (( sgn = mnyfmt( fmtstr , '.' ,-45587,2 ) )) { 1: 178-block 0 1: 178-block 1 1: 179: assertTrue( eqstr( sgn, "-,455.87" ) ); 1: 179-block 0 1: 179-block 1 1: 180: assertTrue( eqstr( fmtstr, "0,00-,455.87" ) ); 1: 180-block 0 1: 180-block 1 -: 181: // handle the "-," problem 1: 182: if ( (*sgn=='-') && (','==*(sgn+1)) ) { 1: 182-block 0 1: 182-block 1 1: 183: ++sgn; *sgn = '-'; // put '-' sign in a nice place 1: 183-block 0 -: 184: } 1: 185: assertTrue( eqstr( sgn, "-455.87" ) ); 1: 185-block 0 1: 185-block 1 1: 186: assertTrue( eqstr( fmtstr, "0,00--455.87" ) ); 1: 186-block 0 1: 186-block 1 -: 187: } -: 188:}} -: 189: -: 190:{{ // test.neg.comma.more -: 191: char *sgn, fmtstr[mnyfmt_size]; 1: 192: strcpy( fmtstr , "9,999" ); 1: 193: if (( sgn = mnyfmt( fmtstr , '.' ,-2455,0 ) )) { 1: 193-block 0 1: 193-block 1 #####: 194: assertFalse( eqstr( sgn, "-2,455" ) ); $$$$$: 194-block 0 $$$$$: 194-block 1 $$$$$: 194-block 2 -: 195: // another '9' is needed to format! -: 196: // '-' didn't fit on top of a '9' -: 197: } -: 198: else { 1: 199: assertTrue( "5 digits are required to format " "-2,455" ); 1: 199-block 0 1: 200: assertTrue( sgn == (char*)(0) ); 1: 200-block 0 -: 201: } -: 202:}} -: 203: -: 204:{{ // test.-245587 -: 205: char *sgn, fmtstr[mnyfmt_size]; -: 206: 1: 207: strcpy( fmtstr , "999,999,999.99" ); 1: 208: if (( sgn = mnyfmt( fmtstr , '.' ,-245587,2 ) )) { 1: 208-block 0 1: 208-block 1 1: 209: assertTrue( eqstr( fmtstr,"000,0-2,455.87" ) ); 1: 209-block 0 1: 209-block 1 1: 210: assertTrue( eqstr( sgn, "-2,455.87" ) ); 1: 210-block 0 1: 210-block 1 -: 211: // handle the "-," problem 1: 212: if ( (*sgn=='-') && (','==*(sgn+1)) ) { 1: 212-block 0 1: 212-block 1 #####: 213: ++sgn; *sgn = '-'; // put '-' sign in a nice place $$$$$: 213-block 0 -: 214: } 1: 215: assertTrue( eqstr( sgn, "-2,455.87" ) ); 1: 215-block 0 1: 215-block 1 1: 216: assertTrue( eqstr( fmtstr, "000,0-2,455.87" ) ); 1: 216-block 0 1: 216-block 1 1: 217: assertTrue( fmtstr+5 == sgn ); 1: 217-block 0 -: 218: } -: 219:}} -: 220: -: 221:{{ // test.PITFALL -: 222: char *sgn, fmtstr[mnyfmt_size], buffer[mnyfmt_size]; -: 223: 1: 224: strcpy( buffer, "USD$ " ); // Picture clause 1: 225: strcpy( fmtstr , "99,999,999" ); 1: 226: if (( sgn = mnyfmt( fmtstr , '.' ,-102455,87 ) )) { 1: 226-block 0 1: 226-block 1 #####: 227: assertFalse( "ERROR [CE should be 0 not " ",87" "]" ); $$$$$: 227-block 0 $$$$$: 227-block 1 -: 228: } -: 229: else { 1: 230: assertTrue( sgn == 0 ); // NULL means mnyfmt() returns ERROR 1: 230-block 0 -: 231: } -: 232: 1: 233: strcpy( fmtstr , "99,999,999.9999" ); 1: 234: if (( sgn = mnyfmt( fmtstr , '.' ,-1024550077,4 ) )) { 1: 234-block 0 1: 234-block 1 1: 235: assertTrue( eqstr( sgn , "-,102,455.0077" ) ); 1: 235-block 0 1: 235-block 1 -: 236: // handle the "-," problem 1: 237: if ( (*sgn=='-') && (','==*(sgn+1)) ) { 1: 237-block 0 1: 237-block 1 1: 238: ++sgn; *sgn = '-'; // put '-' sign in a nice place 1: 238-block 0 -: 239: } 1: 240: assertTrue( eqstr( sgn , "-102,455.0077" ) ); 1: 240-block 0 1: 240-block 1 -: 241: } -: 242:}} -: 243: -: 244:{{ // test.few.decimals -: 245: char *sgn, fmtstr[mnyfmt_size]; -: 246: 1: 247: strcpy( fmtstr , "999,999,999.9999" ); 1: 248: if (( sgn = mnyfmt( fmtstr , '.' , -124550077,2 ) )) { 1: 248-block 0 1: 248-block 1 1: 249: assertTrue( eqstr( sgn , "-1,245,500.7700" ) ); 1: 249-block 0 1: 249-block 1 -: 250: 1: 251: assertFalse( eqstr( sgn , "-102,455.00" ) ); 1: 251-block 0 1: 251-block 1 1: 252: assertFalse( eqstr( sgn , "-102,455.0077" ) ); 1: 252-block 0 1: 252-block 1 -: 253: } -: 254:}} -: 255: -: 256:{{ // test.overwrite -: 257: typedef struct struct_overwrite { -: 258: long align; // probably aligned -: 259: char bytes_8[8]; // 64 bits: probably aligned -: 260: int int_neg; // -1 usually has all its bits equal to 1 -: 261: } overwrite; -: 262: 1: 263: overwrite o = { 0, {'1','2','3','4','5','6','7','\0' }, -1 }; 1: 264: assertTrue( 8-1==strlen(o.bytes_8) && o.int_neg == -1 ); 1: 264-block 0 1: 264-block 1 1: 264-block 2 $$$$$: 264-block 3 1: 264-block 4 -: 265: 1: 266: strcpy( o.bytes_8, "1234567.." ); // 2 more bytes... 1: 267: assertTrue( 9==strlen(o.bytes_8) ); 1: 267-block 0 1: 268: assertFalse( o.int_neg == -1 && "Adjacent memory overwritten " ); 1: 268-block 0 1: 269: assertTrue( o.int_neg != -1 ); 1: 269-block 0 -: 270: 1: 271: assertTrue( CHAR_BIT == 8 && "8 bits bytes required" ); 1: 271-block 0 -: 272:}} -: 273: -: 274:{{ // test.sgn.ptr -: 275: char *sgn, fmtstr[mnyfmt_size]; // Picture clause 1: 276: strcpy( fmtstr , "999.999.999,99" ); 1: 277: if (( sgn = mnyfmt( fmtstr , ',', 12345678988,2 ) )) { 1: 277-block 0 1: 277-block 1 1: 278: assertTrue( eqstr( fmtstr , "123.456.789,88" ) ); 1: 278-block 0 1: 278-block 1 1: 279: assertTrue( eqstr( fmtstr , sgn ) && (fmtstr == sgn) ); 1: 279-block 0 1: 279-block 1 1: 279-block 2 1: 279-block 3 $$$$$: 279-block 4 1: 279-block 5 -: 280: } 1: 281: strcpy( fmtstr , "999.999.999,99" ); 1: 282: if (( sgn = mnyfmt( fmtstr , ',' , -10245587,2 ) )) { 1: 282-block 0 1: 282-block 1 1: 283: assertTrue( eqstr( fmtstr , "00-.102.455,87" ) ); 1: 283-block 0 1: 283-block 1 1: 284: assertTrue( eqstr( sgn , "-.102.455,87" ) ); 1: 284-block 0 1: 284-block 1 1: 285: if ( (*sgn=='-') && ('.'==*(sgn+1)) ) { ++sgn; *sgn='-'; } 1: 285-block 0 1: 285-block 1 1: 285-block 2 1: 286: assertTrue( eqstr( sgn , "-102.455,87" ) ); 1: 286-block 0 1: 286-block 1 -: 287: } -: 288: { 1: 289: assertFalse( 0077 == 77 ); // 0077 is an octal literal 1: 289-block 0 1: 290: assertTrue( 0077 == 8*7+7 ); // 0077 == 63 decimal 1: 290-block 0 -: 291: } -: 292:}} -: 293: -: 294:{{ // test.too.small -: 295: char *sgn, fmtstr[mnyfmt_size]; 1: 296: strcpy( fmtstr , "999.99999" ); 1: 297: if (( sgn = mnyfmt( fmtstr , '.' , 24558700,4 ) )) { 1: 297-block 0 1: 297-block 1 -: 298: // never executed ==> buffer too small -: 299: // 2455 has 4>3 digits [999.] -: 300: } 1: 301: assertTrue( sgn == 0 ); 1: 301-block 0 1: 302: assertTrue( eqstr( fmtstr , "999.99999") ); 1: 302-block 0 1: 302-block 1 -: 303:}} -: 304: -: 305:{{ // test.parentheses -: 306: char *sgn, fmtstr[mnyfmt_size], buffer[mnyfmt_size]; -: 307: 1: 308: strcpy( buffer, "USD$ " ); 1: 309: strcpy( fmtstr , "9,999,999.999" ); 1: 310: if (( sgn = mnyfmt( fmtstr , '.' ,-102455087,3 ) )) { 1: 310-block 0 1: 310-block 1 1: 311: if ( *sgn=='-' ) { // put parentheses around the formatted value 1: 311-block 0 1: 312: if (','==*(sgn+1)) { ++sgn; *sgn='-'; } // skip comma 1: 312-block 0 1: 312-block 1 1: 313: strcat( buffer , "(" ); 1: 314: strcat( buffer , sgn ); 1: 315: strcat( buffer , ")" ); 1: 316: assertTrue( eqstr( buffer, "USD$ (-102,455.087)") ); 1: 316-block 0 1: 316-block 1 1: 316-block 2 -: 317: } -: 318: else { #####: 319: strcat( buffer , sgn ); $$$$$: 319-block 0 -: 320: } -: 321: } -: 322:}} -: 323: -: 324:{{ -: 325: typedef char mnyfmt_size_96_is_enough -: 326: [ (( (65536.0 * 65536.0 * 65536.0 * 65536.0) < 1.0e20 ) ? 1 :-1 ) ]; 1: 327: mnyfmt_size_96_is_enough ch; 1: 328: assertTrue( 1 == sizeof(ch) ); 1: 328-block 0 1: 328-block 1 1: 328-block 2 1: 328-block 3 -: 329:}} -: 330: -: 331:{{ // test.parentheses.no -: 332: char *sgn, fmtstr[mnyfmt_size], buffer[mnyfmt_size]; -: 333: 1: 334: strcpy( fmtstr , "9,999,999.999" ); 1: 335: sgn = mnyfmt( fmtstr , '.' ,2455087,3 ); 1: 335-block 0 1: 336: strcpy( buffer, "USD$ " ); 1: 337: if ( sgn!=0 ) { 1: 337-block 0 1: 338: if ( *sgn=='-' ) { // put parentheses around formatted value 1: 338-block 0 #####: 339: strcat( buffer , "(" ); #####: 340: strcat( buffer , sgn ); #####: 341: strcat( buffer , ")" ); $$$$$: 341-block 0 -: 342: } -: 343: else { 1: 344: strcat( buffer , sgn ); 1: 345: assertTrue( eqstr( buffer, "USD$ 2,455.087") ); 1: 345-block 0 1: 345-block 1 -: 346: } -: 347: } -: 348:}} -: 349: -: 350:{{ // test.asterisks -: 351: char *sgn, fmtstr[mnyfmt_size]; -: 352: 1: 353: strcpy( fmtstr , "$9,999,999.999" ); 1: 354: if (( sgn = mnyfmt( fmtstr , '.' , -455870,3 ) )) { 1: 354-block 0 1: 354-block 1 1: 355: if ( (*sgn=='-') && (','==*(sgn+1)) ) { ++sgn; *sgn='-'; } 1: 355-block 0 1: 355-block 1 1: 355-block 2 1: 356: assertTrue( eqstr( sgn , "-455.870") ); 1: 356-block 0 1: 356-block 1 6: 357: for ( --sgn; (sgn!=fmtstr ); --sgn ) { 1: 357-block 0 5: 357-block 1 6: 357-block 2 5: 358: *sgn = '*'; // avoid writing over "$" -: 359: } 1: 360: assertTrue( eqstr( fmtstr , "$*****-455.870" ) ); 1: 360-block 0 1: 360-block 1 -: 361: } -: 362:}} -: 363: -: 364:{{ // test.modf -: 365: char *sgn, fmtstr[mnyfmt_size]; -: 366: -: 367: double intdouble, fractdouble; -: 368: long intpart, fracpart; -: 369: unsigned CE, ten_pow_CE; -: 370: 1: 371: CE = 5; ten_pow_CE = 100*1000; // 10^CE 1: 372: fractdouble = modf( 2455.87 , &intdouble ); 1: 373: intpart = intdouble; // 2455 1: 374: fracpart = (unsigned)(fractdouble*ten_pow_CE); // .86000 -: 375: { 1: 376: assertFalse( fracpart == 87000 && "???"); 1: 376-block 0 1: 377: assertTrue( fracpart == 86999 && "!!!"); // binary rounding... 1: 377-block 0 -: 378: } 1: 379: strcpy( fmtstr , "[[ 999,999.99999 ]]" ); 1: 380: if (( sgn = mnyfmt( fmtstr , '.' , intpart*ten_pow_CE+fracpart,CE ) )) { 1: 380-block 0 1: 380-block 1 1: 381: assertTrue( eqstr( fmtstr , "[[ 002,455.86999 ]]" ) ); 1: 381-block 0 1: 381-block 1 1: 382: assertTrue( eqstr( sgn , "2,455.86999 ]]") ); 1: 382-block 0 1: 382-block 1 -: 383: { // std::round_toward_infinity 1: 384: fracpart = (unsigned)(ceil(fractdouble*100))*1000; 1: 385: strcpy( fmtstr , "[[ 999,999.99999 ]]" ); 1: 386: assertTrue( fracpart == 87000 && "!!!"); 1: 386-block 0 1: 387: if (( sgn = mnyfmt( fmtstr , '.' , intpart*ten_pow_CE+fracpart,5 ) )) { 1: 387-block 0 1: 387-block 1 1: 388: assertTrue( eqstr( sgn, "2,455.87000 ]]") ); 1: 388-block 0 1: 388-block 1 -: 389: } -: 390: } -: 391: } -: 392:}} -: 393: -: 394:{{ // test.SCALE -: 395: #define SCALE(f,CE) ( (mnyfmt_long) ( (f) * 1.0e##CE ) ) // beware of truncation -: 396: -: 397: char *sgn, fmtstr[mnyfmt_size]; 1: 398: double val_double = -102455.87; -: 399: 1: 400: strcpy( fmtstr , "99,999,999.99999" ); 1: 401: if (( sgn = mnyfmt( fmtstr , '.' ,SCALE(val_double,2),2 ) )) { 1: 401-block 0 1: 401-block 1 1: 402: assertTrue( eqstr( fmtstr , "0-,102,455.86000") ); 1: 402-block 0 1: 402-block 1 1: 403: if ( (*sgn=='-') && (','==*(sgn+1)) ) { ++sgn; *sgn='-'; } 1: 403-block 0 1: 403-block 1 1: 403-block 2 1: 404: assertTrue( eqstr( sgn, "-102,455.86000") ); 1: 404-block 0 1: 404-block 1 1: 404-block 2 -: 405: } // rounding and trucations yields .86 instead of .87 -: 406: else { #####: 407: assertFalse( "ERROR [???]: " "-102,455.86000" ); $$$$$: 407-block 0 -: 408: } -: 409:}} -: 410: #undef SCALE -: 411: -: 412:{{ // test.0-7.SCALE -: 413: #define SCALE(f,CE) ( (mnyfmt_long) ( (f) * 1.0e##CE ) ) -: 414: { 1: 415: assertTrue ( SCALE(1,0) == 1 ); 1: 415-block 0 1: 416: assertTrue ( SCALE(1,1) == 10 ); 1: 417: assertTrue ( SCALE(1,2) == 100 ); 1: 418: assertTrue ( SCALE(1,3) == 1000 ); 1: 419: assertTrue ( SCALE(1,4) == 10000 ); 1: 420: assertTrue ( SCALE(1,5) == 100000 ); 1: 421: assertTrue ( SCALE(1,6) == 1000000 ); 1: 422: assertTrue ( SCALE(1,7) == 10000000 ); -: 423: } -: 424: #undef SCALE -: 425:}} -: 426: -: 427:{{ // test.four.decimals -: 428: char *sgn, fmtstr[mnyfmt_size]; -: 429: -: 430: double intdouble, fractdouble; -: 431: long intpart, fracpart; -: 432: unsigned CE; -: 433: 1: 434: fractdouble = modf( 2455.87 , &intdouble ); 1: 435: intpart = intdouble*10000; // 2455 1: 436: fracpart = (unsigned)(fractdouble*100)*100; // .8600 1: 437: CE = 4; -: 438: { 1: 439: assertFalse( fracpart == 8700 && "???"); 1: 440: assertTrue( fracpart == 8600 && "!!!"); // binary rounding... 1: 440-block 0 -: 441: } 1: 442: strcpy( fmtstr , "[[ 999,999.9999 ]]" ); 1: 443: if (( sgn = mnyfmt( fmtstr , '.' , intpart+fracpart,CE ) )) { 1: 443-block 0 1: 443-block 1 1: 444: assertTrue( eqstr( fmtstr , "[[ 002,455.8600 ]]" ) ); 1: 444-block 0 1: 444-block 1 1: 445: assertTrue( eqstr( sgn , "2,455.8600 ]]") ); 1: 445-block 0 1: 445-block 1 -: 446: { // std::round_toward_infinity 1: 447: fracpart = (unsigned)(ceil(fractdouble*100))*100; 1: 448: strcpy( fmtstr , "[[ 999,999.9999 ]]" ); 1: 449: assertTrue( fracpart == 8700 && "!!!"); 1: 449-block 0 1: 450: if (( sgn = mnyfmt( fmtstr , '.' , intpart+fracpart,CE ) )) { 1: 450-block 0 1: 450-block 1 1: 451: assertTrue( eqstr( sgn, "2,455.8700 ]]") ); 1: 451-block 0 1: 451-block 1 -: 452: } -: 453: } -: 454: } -: 455:}} -: 456: -: 457:// This works in the Borland C++ 3.1 IDE -: 458:// Alt-Options -> Compiler -> Code generation... -: 459:// -> Defines MNYFMT_NO_LONG_LONG -: 460:// - Borland C++ 3.1 does not support the (long long) integer type -: 461: -: 462:{{ // test.limit -: 463: char *sgn, fmtstr[mnyfmt_size]; -: 464: #ifndef MNYFMT_NO_LONG_LONG 1: 465: mnyfmt_long max = LONG_LONG_MAX; 1: 466: strcpy( fmtstr , "999,999,999,999,999,999,999" ); 1: 466-block 0 -: 467: // 9,223,372,036,854,775,807 -: 468: if ( 9223372036854775807LL == LONG_LONG_MAX ) { 1: 469: if (( sgn = mnyfmt( fmtstr , ' ' , max,0 ) )) { 1: 469-block 0 1: 469-block 1 1: 470: assertTrue( eqstr( "9,223,372,036,854,775,807", sgn ) ); 1: 470-block 0 1: 470-block 1 1: 470-block 2 -: 471: } -: 472: } -: 473: else { -: 474: assertFalse( "BEWARE: (long long) is not 8 bytes wide" ); -: 475: } -: 476: #endif -: 477: { 1: 478: mnyfmt_long max = LONG_MAX; 1: 479: strcpy( fmtstr , "999,999,999,999" ); 1: 479-block 0 -: 480: // 2,147,483,647 -: 481: if ( 2147483647L == LONG_MAX ) { 1: 482: if (( sgn = mnyfmt( fmtstr , ' ' , max,0 ) )) { 1: 482-block 0 1: 482-block 1 1: 483: assertTrue( eqstr( "2,147,483,647", sgn ) ); 1: 483-block 0 1: 483-block 1 1: 483-block 2 -: 484: } -: 485: } -: 486: else { -: 487: assertFalse( "BEWARE: (long) is not 4 bytes wide" ); -: 488: } -: 489: } -: 490:}} -: 491: -: 492:{{ // test.fract.zero -: 493: char *sgn, fmtstr[mnyfmt_size]; -: 494: // The fraction 643/2136 approximates log10(2) to 7 significant digits. 1: 495: int N = ( ( CHAR_BIT * sizeof(int) - 1 ) * 643 / 2136 ) * (10000*10000); -: 496: 1: 497: strcpy( fmtstr , "999,999,999,999.999999" ); 1: 498: if (( sgn = mnyfmt( fmtstr , '.', -N,0 ) )) { 1: 498-block 0 1: 498-block 1 1: 499: if ( (*sgn=='-') && (','==*(sgn+1)) ) { ++sgn; *sgn='-'; } 1: 499-block 0 1: 499-block 1 1: 499-block 2 1: 500: assertTrue( eqstr( fmtstr ,"00--900,000,000.000000" ) ); 1: 500-block 0 1: 500-block 1 1: 501: assertTrue( eqstr( sgn , "-900,000,000.000000" ) ); 1: 501-block 0 1: 501-block 1 -: 502: 1: 503: assertFalse( eqstr( fmtstr , "00--455.000000012" ) ); 1: 503-block 0 1: 503-block 1 1: 504: assertFalse( eqstr( sgn , "-455.000000012" ) ); 1: 504-block 0 1: 504-block 1 -: 505: } -: 506:}} -: 507: -: 508:{{ // test.copy.wchar -: 509: {{ // Convert a char[] into a wchar_t[] -: 510: char *src, chBuff[128]; -: 511: wchar_t *dst, *wcBuff; 1: 512: strcpy (chBuff, "Convert me to (wchar_t)"); 1: 513: wcBuff = (wchar_t*)( malloc( sizeof(chBuff)*sizeof(wchar_t) ) ); 24: 514: for ( dst=wcBuff,src=chBuff; (*dst=*src); ++dst,++src ) {} 1: 514-block 0 23: 514-block 1 24: 514-block 2 -: 515: // ... C++ will let you use more sophisticated stuff 1: 516: free(wcBuff); -: 517: }} -: 518: { 1: 519: assertTrue( 1==1 ); // Run to cursor 1: 519-block 0 -: 520: } -: 521: if ( 0 ) { -: 522: #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0410) -: 523: #define wcslen strlen -: 524: #endif -: 525: /// Number of letters in array. -: 526: #define DIM 256 -: 527: char SRC[DIM], *src; -: 528: wchar_t DST[DIM], *dst; -: 529: strcpy( SRC, "Convert me to (wchar_t)"); -: 530: // strlen()==01234567890123456789012345 -: 531: for ( dst=DST,src=SRC; (*dst=*src); ++dst,++src ) {} -: 532: -: 533: assertTrue( DIM==sizeof(SRC) ); -: 534: assertTrue( strlen(SRC)==23 ); -: 535: -: 536: printf( "sizeof(wchar_t) == %d\n", sizeof(wchar_t) ); -: 537: printf("%s strlen(SRC)==%d\n", SRC , strlen(SRC) ); -: 538: printf("%ls wcslen(SRC)==%d\n", DST , wcslen(DST) ); -: 539: #undef wcslen -: 540: #undef DIM -: 541: { -: 542: unsigned i; -: 543: for ( i=0 ; i "rupees." 1: 592-block 0 -: 593: } 1: 594: assertTrue( eqstr( sgn , "3 crores 25 lakhs 84,729 rupees 25 paise" )); 1: 594-block 0 1: 594-block 1 -: 595: -: 596: // Rp3,25,84,729.25 is read as three crore(s), twenty-five lakh(s), -: 597: // eighty-four thousand, seven hundred and twenty-nine rupees and -: 598: // twenty-five paise. -: 599: // - http://en.wikipedia.org/wiki/Indian_rupee#Numeral_system -: 600:}} -: 601:#endif -: 602: -: 603:{{ // test.times -: 604: char *sgn, fmtstr[mnyfmt_size]; -: 605: 1: 606: strcpy( fmtstr , "99/99/9999" ); 1: 607: if (( sgn = mnyfmt( fmtstr , 000, 9272002,0 ) )) { 1: 607-block 0 1: 607-block 1 1: 608: assertTrue( eqstr( fmtstr , "09/27/2002" ) ); 1: 608-block 0 1: 608-block 1 1: 609: assertTrue( eqstr( sgn , "9/27/2002" ) ); 1: 609-block 0 1: 609-block 1 -: 610: } 1: 611: strcpy( fmtstr , "99:99:99" ); 1: 612: if (( sgn = mnyfmt( fmtstr , '?', 21435,0 ))) { 1: 612-block 0 1: 612-block 1 1: 613: assertTrue( eqstr( fmtstr , "02:14:35") ); 1: 613-block 0 1: 613-block 1 1: 614: assertTrue( eqstr( sgn , "2:14:35") ); 1: 614-block 0 1: 614-block 1 -: 615: } -: 616:}} -: 617: -: 618:{{ // test.times.more -: 619: char *sgn, fmtstr[mnyfmt_size]; 1: 620: strcpy( fmtstr , "99-99-9999" ); 1: 621: if (( sgn = mnyfmt( fmtstr , '*' , 07272002,0 ) )) { // 0... octal 1: 621-block 0 1: 621-block 1 1: 622: assertFalse( eqstr( sgn , "07-27-2002" ) ); 1: 622-block 0 1: 622-block 1 1: 623: assertTrue( eqstr( sgn , "1-93-0242" ) ); 1: 623-block 0 1: 623-block 1 1: 624: assertTrue( eqstr( fmtstr , "01-93-0242" ) ); 1: 624-block 0 1: 624-block 1 1: 625: assertTrue( "BEWARE of octal literal !!!" ); 1: 625-block 0 -: 626: } 1: 627: strcpy( fmtstr , "99-99-9999" ); 1: 628: if (( sgn = mnyfmt( fmtstr , '*' , 27092002,0 ) )) { 1: 628-block 0 1: 628-block 1 1: 629: assertTrue( eqstr( sgn , "27-09-2002" ) ); 1: 629-block 0 1: 629-block 1 -: 630: } -: 631: 1: 632: strcpy( fmtstr , "99-99-9999" ); 1: 633: if (( sgn = mnyfmt( fmtstr , '*' , 1012002,0 ) )) { 1: 633-block 0 1: 633-block 1 1: 634: assertTrue( eqstr( sgn , "1-01-2002" ) ); 1: 634-block 0 1: 634-block 1 1: 635: assertTrue( eqstr( fmtstr , "01-01-2002" ) ); 1: 635-block 0 1: 635-block 1 -: 636: } -: 637: 1: 638: strcpy( fmtstr , "999,999,999" ); 1: 639: if (( sgn = mnyfmt( fmtstr , ':' , 27092002,0 ) )) { 1: 639-block 0 1: 639-block 1 1: 640: assertTrue( eqstr( sgn , "27,092,002" ) ); 1: 640-block 0 1: 640-block 1 -: 641: } -: 642: 1: 643: strcpy( fmtstr , "999,999,999" ); 1: 644: if (( sgn = mnyfmt( fmtstr , '.' , 123456789,0 ) )) { 1: 644-block 0 1: 644-block 1 1: 645: assertTrue( eqstr( sgn , "123,456,789" ) ); 1: 645-block 0 1: 645-block 1 -: 646: } -: 647:}} -: 648: -: 649:#ifndef MNYFMT_NO_LONG_LONG -: 650:{{ // test.longlongmax -: 651: char *sgn, fmtstr[mnyfmt_size]; -: 652: 1: 653: mnyfmt_long max = -LONG_LONG_MAX-1; 1: 654: strcpy( fmtstr , "99,999,999,999,999,999,999" ); -: 655: // 9,223,372,036,854,775,807 1: 656: sgn = mnyfmt( fmtstr , ' ' , max,0 ); 1: 656-block 0 1: 657: assertTrue( sgn==0 ); 1: 657-block 0 1: 658: assertTrue( eqstr( "99,999,999,999,999,999,999", fmtstr ) ); 1: 658-block 0 1: 658-block 1 -: 659:}} -: 660:#else -: 661:{{ // test.longmax -: 662: char *sgn, fmtstr[mnyfmt_size]; -: 663: -: 664: mnyfmt_long max = -LONG_MAX-1; -: 665: strcpy( fmtstr , "9,999,999,999" ); -: 666: // 2,147,483,647 -: 667: sgn = mnyfmt( fmtstr , ' ' , max,0 ); -: 668: assertTrue( sgn==0 ); -: 669: assertTrue( eqstr( "9,999,999,999", fmtstr ) ); -: 670: assertTrue( sizeof(mnyfmt_long)==sizeof(long) ); -: 671:}} -: 672:#endif -: 673: -: 674:{{ // test.no.strcpy -: 675: char *sgn, fmtstr[mnyfmt_size]; -: 676: 1: 677: strcpy( fmtstr , "9,999." ); 1: 678: if (( sgn = mnyfmt( fmtstr , '.' , 2455,0 ) )) { 1: 678-block 0 1: 678-block 1 1: 679: assertTrue( eqstr( sgn , "2,455." ) ); 1: 679-block 0 1: 679-block 1 -: 680: } -: 681: 1: 682: if (( sgn = mnyfmt( fmtstr , '.' , 1400,0 ) )) { 1: 682-block 0 1: 682-block 1 -: 683: // never executed: missing strcpy() -: 684: // no char in "2,455." is a format char -: 685: } -: 686: else { 1: 687: assertFalse( eqstr( fmtstr , "1,400." ) ); 1: 687-block 0 1: 687-block 1 1: 688: assertTrue( eqstr( fmtstr , "2,455." ) ); // ??? 1: 688-block 0 1: 688-block 1 1: 689: assertTrue( "BEWARE: missing strcpy()" ); // ??? 1: 689-block 0 -: 690: { 1: 691: strcpy( fmtstr , "9,999." ); 1: 692: sgn = mnyfmt( fmtstr , '.' , 1400,0 ); 1: 692-block 0 1: 693: assertTrue( eqstr( sgn , "1,400." ) ); 1: 693-block 0 1: 693-block 1 -: 694: } -: 695: } -: 696:}} -: 697: -: 698:{{ // test.dot.comma -: 699: char *sgn, fmtstr[mnyfmt_size]; 1: 700: strcpy( fmtstr , ".9,999." ); // leading dot 1: 701: sgn = mnyfmt( fmtstr , '.' , 2455,0 ); // with dot '.' 1: 701-block 0 1: 702: assertTrue( sgn == 0 && !sgn ); 1: 702-block 0 1: 702-block 1 1: 702-block 2 $$$$$: 702-block 3 1: 702-block 4 1: 703: assertTrue( eqstr( fmtstr , ".9,999." ) ); 1: 703-block 0 1: 703-block 1 1: 704: sgn = mnyfmt( fmtstr , ',' , 2455,0 ); // with comma ',' 1: 704-block 0 1: 705: assertTrue( sgn == 0 && !sgn ); 1: 705-block 0 1: 705-block 1 1: 705-block 2 $$$$$: 705-block 3 1: 705-block 4 1: 706: assertTrue( eqstr( fmtstr , ".9,999." ) ); 1: 706-block 0 1: 706-block 1 -: 707: // 2455 has 4 digits ==> it needs '9' format digits before dec.sep -: 708: 1: 709: strcpy( fmtstr , "9,999" ); 1: 710: sgn = mnyfmt( fmtstr , '.' , 2455,0 ); // with dot '.' 1: 710-block 0 1: 711: assertTrue( sgn && sgn != 0 ); 1: 711-block 0 1: 711-block 1 1: 711-block 2 $$$$$: 711-block 3 1: 711-block 4 1: 712: assertTrue( eqstr( fmtstr , "2,455" ) ); 1: 712-block 0 1: 712-block 1 1: 713: sgn = mnyfmt( fmtstr , ',' , 2455,0 ); // with comma ',' 1: 713-block 0 1: 714: assertTrue( sgn == 0 && !sgn ); 1: 714-block 0 1: 714-block 1 1: 714-block 2 $$$$$: 714-block 3 1: 714-block 4 -: 715: 1: 716: strcpy( fmtstr , "9" ); 1: 717: sgn = mnyfmt( fmtstr , ',' , 0,0 ); 1: 717-block 0 1: 718: assertTrue( eqstr( fmtstr , "0" ) ); 1: 718-block 0 1: 718-block 1 1: 719: strcpy( fmtstr , "9" ); 1: 720: sgn = mnyfmt( fmtstr , ',' , 9,0 ); 1: 720-block 0 1: 721: assertTrue( eqstr( fmtstr , "9" ) ); 1: 721-block 0 1: 721-block 1 -: 722:}} -: 723: -: 724:{{ // test.zero -: 725: char *sgn, fmtstr[mnyfmt_size]; -: 726: 1: 727: strcpy( fmtstr , "9.999." ); 1: 728: sgn = mnyfmt( fmtstr , '.' ,-0,0 ); 1: 728-block 0 1: 729: assertTrue( eqstr( fmtstr , "0.000." ) ); 1: 729-block 0 1: 729-block 1 1: 730: assertTrue( eqstr( fmtstr , sgn ) ); 1: 730-block 0 1: 730-block 1 -: 731: 1: 732: strcpy( fmtstr , "9," ); 1: 733: sgn = mnyfmt( fmtstr , ',' ,-0,0 ); 1: 733-block 0 1: 734: assertTrue( eqstr( fmtstr , "0," ) ); 1: 734-block 0 1: 734-block 1 -: 735: 1: 736: strcpy( fmtstr , "," ); 1: 737: sgn = mnyfmt( fmtstr , ',' ,0,0 ); 1: 737-block 0 1: 738: assertTrue( eqstr( fmtstr , "," ) ); 1: 738-block 0 1: 738-block 1 -: 739: 1: 740: strcpy( fmtstr , ",9" ); 1: 741: sgn = mnyfmt( fmtstr , ',' ,0,0 ); 1: 741-block 0 1: 742: assertTrue( eqstr( fmtstr , ",9" ) ); 1: 742-block 0 1: 742-block 1 -: 743: 1: 744: strcpy( fmtstr , "9,9" ); 1: 745: sgn = mnyfmt( fmtstr , ',' ,0,0 ); 1: 745-block 0 1: 746: assertTrue( eqstr( fmtstr , "0,0" ) ); 1: 746-block 0 1: 746-block 1 -: 747: 1: 748: strcpy( fmtstr , "9,9999999" ); 1: 749: sgn = mnyfmt( fmtstr , ',' ,0,0 ); 1: 749-block 0 1: 750: assertTrue( eqstr( fmtstr , "0,0000000" ) ); 1: 750-block 0 1: 750-block 1 -: 751: 1: 752: strcpy( fmtstr , "" ); 1: 753: sgn = mnyfmt( fmtstr , ',' ,1241,2 ); 1: 753-block 0 1: 754: assertTrue( eqstr( fmtstr , "" ) ); 1: 754-block 0 1: 754-block 1 -: 755: 1: 756: strcpy( fmtstr , "0123456" ); 1: 757: assertTrue( eqstr( fmtstr+1 , "123456" ) ); 1: 757-block 0 1: 757-block 1 1: 758: *fmtstr = 0; 1: 759: sgn = mnyfmt( fmtstr , ',' ,1,0 ); 1: 759-block 0 1: 760: assertTrue( eqstr( fmtstr , "" ) ); 1: 760-block 0 1: 760-block 1 1: 761: assertTrue( eqstr( fmtstr+1 , "123456" ) ); 1: 761-block 0 1: 761-block 1 -: 762:}} -: 763: -: 764:{{ // test.nines -: 765: char *sgn, fmtstr[mnyfmt_size]; 1: 766: strcpy( fmtstr , "999,99,999" ); 1: 767: sgn = mnyfmt( fmtstr , '.' , 99999999,0 ); 1: 767-block 0 1: 768: assertTrue( eqstr( sgn , "999,99,999" ) ); 1: 768-block 0 1: 768-block 1 -: 769: 1: 770: strcpy( fmtstr , "999,99,999" ); 1: 771: sgn = mnyfmt( fmtstr , '.' , 88888888,0 ); 1: 771-block 0 1: 772: assertTrue( eqstr( sgn , "888,88,888" ) ); 1: 772-block 0 1: 772-block 1 -: 773:}} -: 774: -: 775:{{ // test.no.dec -: 776: char *sgn, fmtstr[mnyfmt_size]; -: 777: 1: 778: strcpy( fmtstr , "9,999." ); // Ok: '.' in "9,999." 1: 779: sgn = mnyfmt( fmtstr , '.' , 2455,0 ); 1: 779-block 0 1: 780: assertTrue( eqstr( fmtstr , "2,455." ) ); 1: 780-block 0 1: 780-block 1 -: 781: 1: 782: strcpy( fmtstr , "9.999." ); 1: 783: sgn = mnyfmt( fmtstr , '?' , 2455,0 ); // NO '?' in "9,999." 1: 783-block 0 1: 784: assertTrue( strchr( fmtstr, '?' ) == 0 ); 1: 784-block 0 1: 785: assertTrue( eqstr( fmtstr , "2.455." ) ); 1: 785-block 0 1: 785-block 1 1: 786: assertTrue( eqstr( fmtstr , sgn ) ); 1: 786-block 0 1: 786-block 1 -: 787:}} -: 788: -: 789:{{ // test.Banana -: 790: char *sgn, fmtstr[mnyfmt_size]; -: 791: // - 24 55 .8 1: 792: strcpy( fmtstr , "Banana 99 x099-099 32 .9.999." ); 1: 793: if (( sgn = mnyfmt( fmtstr , '.' ,-245587,2 ) )) { 1: 793-block 0 1: 793-block 1 1: 794: assertTrue( eqstr( "Banana 0- x024-055 32 .8.999.", fmtstr ) ); 1: 794-block 0 1: 794-block 1 1: 795: assertTrue( eqstr( "- x024-055 32 .8.999.", sgn ) ); 1: 795-block 0 1: 795-block 1 -: 796: 1: 797: assertFalse( eqstr( "Banana 0- x024-055 32 .7.999.", fmtstr ) ); 1: 797-block 0 1: 797-block 1 1: 798: assertFalse( eqstr( "- x024-055 32 .7.999.", sgn ) ); 1: 798-block 0 1: 798-block 1 -: 799: } -: 800:}} -: 801: -: 802:{{ // test.null.string -: 803: char *sgn, fmtstr[mnyfmt_size]; -: 804: // - 24 55 .8 1: 805: strcpy( fmtstr , "Banana 99 x099-099 32 .9.999." ); 1: 806: strcpy( fmtstr , "" ); 1: 807: assertTrue( ! (* fmtstr) ); 1: 807-block 0 1: 808: assertTrue( eqstr( fmtstr+1, "anana 99 x099-099 32 .9.999." ) ); 1: 808-block 0 1: 808-block 1 1: 809: if (( sgn = mnyfmt( fmtstr , '.' ,-245587,2 ) )) { 1: 809-block 0 1: 809-block 1 #####: 810: assertFalse( "NULL string error!!!" ); $$$$$: 810-block 0 #####: 811: assertFalse( eqstr( "anana 0- x024-055 32 .8.999.", fmtstr+1 ) ); $$$$$: 811-block 0 $$$$$: 811-block 1 $$$$$: 811-block 2 -: 812: } -: 813: else { 1: 814: assertTrue( "Sorry: I forgot to use a non null string" ); 1: 814-block 0 -: 815: } -: 816:}} -: 817: -: 818:{{ // test.null.ptr -: 819: char *sgn; 1: 820: if (( sgn = mnyfmt( (char*)(0) , '.' ,-245587,2 ) )) { 1: 820-block 0 #####: 821: assertFalse( "NULL pointer error!!!" ); $$$$$: 821-block 0 -: 822: } -: 823: else { 1: 824: assertTrue( "Sorry: I forgot to use a non null pointer" ); 1: 824-block 0 -: 825: } -: 826:}} -: 827: -: 828:{{ // test.mnyfmt.ptr -: 829: typedef char* (*format_money_type)( char *, char , mnyfmt_long , unsigned ); 1: 830: format_money_type format_money = mnyfmt_wrap; -: 831: char *sgn, fmtstr[mnyfmt_size]; 1: 832: strcpy( fmtstr , "9,999." ); 1: 833: if (( sgn = format_money( fmtstr , '.' , 245587,2 ) )) { 1: 833-block 0 1: 833-block 1 1: 834: assertTrue( eqstr( fmtstr , "2,455." ) ); 1: 834-block 0 1: 834-block 1 1: 835: assertTrue( eqstr( fmtstr , sgn ) ); 1: 835-block 0 1: 835-block 1 -: 836: } -: 837:}} -: 838: -: 839: -: 840:{{ // test.modf() ==> double modf( double param, double * intpart ); -: 841: { // modf() with positive numbers -: 842: double fractpart, intpart; 1: 843: fractpart = modf( 3.14159265 , &intpart ); 1: 844: assertTrue( intpart == 3.0 ); 1: 844-block 0 1: 845: assertTrue( fabs( fractpart - 0.14159265 ) < pow(10.0,-8.0) ); 1: 845-block 0 -: 846: 1: 847: if ( fractpart == 0.14159265 ) { 1: 847-block 0 #####: 848: assertFalse( "NEVER executed due to floating point rounding error" ); $$$$$: 848-block 0 -: 849: // What Every Computer Scientist Should Know About Floating-Point Arithmetic #####: 850: assertTrue( !!! "http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html" ); $$$$$: 850-block 0 -: 851: } -: 852: } -: 853: { // modf() with negative numbers -: 854: // NOTE ==> each part has the same sign as param. -: 855: double fractpart, intpart; 1: 856: fractpart = modf( -3.14159265 , &intpart ); 1: 857: assertTrue( intpart == -3.0 ); // intpart is negative 1: 857-block 0 1: 858: assertTrue( fractpart < 0.0 ); // fractpart is negative 1: 858-block 0 1: 859: assertTrue( fabs( -fractpart - 0.14159265 ) < pow(10.0,-8.0) ); 1: 859-block 0 -: 860: } -: 861:}} -: 862: -: 863:{{ // test.round -: 864: double adh_round(double val); -: 865: /// [Dirty] Trick to force round() to be \c adh_round() -: 866: #define round adh_round 1: 867: assertTrue( round( 1.7 ) == 2.0 ); 1: 867-block 0 1: 868: assertTrue( round( 1.5 ) == 2.0 ); 1: 869: assertTrue( round( 1.3 ) == 1.0 ); -: 870: 1: 871: assertTrue( round( -1.3 ) == -1.0 ); 1: 872: assertTrue( round( -1.5 ) == -2.0 ); 1: 873: assertTrue( round( -1.7 ) == -2.0 ); -: 874: 1: 875: assertTrue( round( 0.1 ) == 0.0 ); 1: 876: assertTrue( round( -0.1 ) == 0.0 ); 1: 877: assertTrue( round( -0.9 ) == -1.0 ); -: 878: 1: 879: assertTrue( round( 11.7 ) == 12.0 ); 1: 880: assertTrue( round( 11.5 ) == 12.0 ); 1: 881: assertTrue( round( 11.3 ) == 11.0 ); -: 882: 1: 883: assertTrue( round( -11.3 ) == -11.0 ); 1: 884: assertTrue( round( -11.5 ) == -12.0 ); 1: 885: assertTrue( round( -11.7 ) == -12.0 ); -: 886: #undef round -: 887:}} 1: 888: return 0; 1: 888-block 0 %%%%%: 888-block 1 %%%%%: 888-block 2 %%%%%: 888-block 3 %%%%%: 888-block 4 %%%%%: 888-block 5 %%%%%: 888-block 6 %%%%%: 888-block 7 %%%%%: 888-block 8 %%%%%: 888-block 9 %%%%%: 888-block 10 %%%%%: 888-block 11 $$$$$: 888-block 12 %%%%%: 888-block 13 %%%%%: 888-block 14 %%%%%: 888-block 15 %%%%%: 888-block 16 %%%%%: 888-block 17 %%%%%: 888-block 18 %%%%%: 888-block 19 %%%%%: 888-block 20 %%%%%: 888-block 21 %%%%%: 888-block 22 %%%%%: 888-block 23 %%%%%: 888-block 24 %%%%%: 888-block 25 %%%%%: 888-block 26 %%%%%: 888-block 27 %%%%%: 888-block 28 %%%%%: 888-block 29 %%%%%: 888-block 30 %%%%%: 888-block 31 %%%%%: 888-block 32 %%%%%: 888-block 33 -: 889:} -: 890: 1: 891:void test_str2mnyCE() { 1: 891-block 0 -: 892:{{ // test::07::str2mnyCE() 1: 893: assertTrue( -1024558700 == str2mnyCE(" -102,455.87", '.', 4) ); 1: 893-block 0 1: 894: assertTrue( -102455870 == str2mnyCE(" -102,455.87", '.', 3) ); 1: 895: assertTrue( -10245587 == str2mnyCE(" -102,455.87", '.', 2) ); 1: 896: assertTrue( -1024558 == str2mnyCE(" -102,455.87", '.', 1) ); 1: 897: assertTrue( -102455 == str2mnyCE(" -102,455.87", '.', 0) ); -: 898: 1: 899: assertTrue( 1024550700 == str2mnyCE(" 102,455.07", '.', 4) ); 1: 900: assertTrue( 102455070 == str2mnyCE(" 102,455.07", '.', 3) ); 1: 901: assertTrue( 10245507 == str2mnyCE(" 102,455.07", '.', 2) ); 1: 902: assertTrue( 1024550 == str2mnyCE(" 102,455.07", '.', 1) ); 1: 903: assertTrue( 102455 == str2mnyCE(" 102,455.07", '.', 0) ); -: 904:}} -: 905:{{ // test::str2mnyCE() 1: 906: assertTrue( -1024550700 == str2mnyCE(" -102,455.07", '.', 4) ); 1: 907: assertTrue( -102455070 == str2mnyCE(" -102,455.07", '.', 3) ); 1: 908: assertTrue( -10245507 == str2mnyCE(" -102,455.07", '.', 2) ); 1: 909: assertTrue( -1024550 == str2mnyCE(" -102,455.07", '.', 1) ); 1: 910: assertTrue( -102455 == str2mnyCE(" -102,455.07", '.', 0) ); -: 911: 1: 912: assertTrue( 1024558700 == str2mnyCE(" 102,455.87", '.', 4) ); 1: 913: assertTrue( 102455870 == str2mnyCE(" 102,455.87", '.', 3) ); 1: 914: assertTrue( 10245587 == str2mnyCE(" 102,455.87", '.', 2) ); 1: 915: assertTrue( 1024558 == str2mnyCE(" 102,455.87", '.', 1) ); 1: 916: assertTrue( 102455 == str2mnyCE(" 102,455.87", '.', 0) ); -: 917:}} -: 918:{ 1: 919: assertTrue( -1024558700 == str2mnyCE("$ -102,455.87", '.', 4) ); 1: 920: assertTrue( 102455 == str2mnyCE("US$102,455.87", '.', 0) ); -: 921: 1: 922: assertTrue( 2455 == str2mnyCE(" 2,455.87", '.', 0) ); 1: 923: assertTrue( 2455 == str2mnyCE(" 2,455.87", '.', 0) ); 1: 924: assertTrue( 2455 == str2mnyCE("US$ 2,455 ", '.', 0) ); 1: 925: assertTrue( 2455 == str2mnyCE("US$ 2,455. ", '.', 0) ); -: 926: 1: 927: assertTrue( 455000 == str2mnyCE("US$ 455. 1", '.', 3) ); 1: 928: assertTrue( 4550000 == str2mnyCE("US$ 455. 2", '.', 4) ); 1: 929: assertTrue( 455000 == str2mnyCE("US$ 455", '.', 3) ); -: 930: 1: 931: assertTrue( 4550000 == str2mnyCE("US$ 455.", '.', 4) ); 1: 932: assertTrue( 0 == str2mnyCE( ".9",'.', 0) ); 1: 933: assertTrue( 9 == str2mnyCE( ".9",'.', 1) ); 1: 934: assertTrue( 9 == str2mnyCE(".000009",'.',6) ); -: 935: 1: 936: assertTrue( 4550000 == str2mnyCE("US$ 455", '.', 4) ); 1: 937: assertTrue( 455 == str2mnyCE("US$ 455", '.', 0) ); -: 938: 1: 939: assertTrue( 0 == str2mnyCE("BANANA",'.', 0) ); 1: 940: assertTrue( 0 == str2mnyCE("BANANA",'.', 4) ); 1: 941: assertTrue( 0 == str2mnyCE("BANANA",'.', 6) ); 1: 942: assertTrue( 0 == str2mnyCE( "",'.', 6) ); 1: 943: assertTrue( 0 == str2mnyCE( "1",'.', 6+1) ); 1: 944: assertTrue( 9 == str2mnyCE( "9",'.', 0) ); -: 945: 1: 946: assertTrue( 0 == str2mnyCE( ".9",'.', 0) ); 1: 947: assertTrue( 9 == str2mnyCE( ".9",'.', 1) ); 1: 948: assertTrue( 9 == str2mnyCE(".000009",'.',6) ); 1: 949: assertTrue( 9000000 == str2mnyCE("9",'.',6) ); 1: 950: assertTrue( 900000 == str2mnyCE(".9",'.',6) ); 1: 951: assertTrue( 0 == str2mnyCE( "-.9",'.', 0) ); 1: 952: assertTrue( -9 == str2mnyCE( "-.9",'.', 1) ); 1: 953: assertTrue( -9 == str2mnyCE("-.000009",'.',6) ); -: 954:} -: 955:{ 1: 956: assertTrue( !0 ); // 'Run to cursor' in Code::Blocks -: 957:} 1: 958:} -: 959: -: 960:/// Round to integer, rounding halfway cases away from zero 15: 961:double adh_round(double val) { // unbiased rounding 15: 961-block 0 -: 962:// return ( (val>0.0) ? floor(val+0.5) : ceil( val-0.5) ); 15: 963: return ( (val>0.0) ? floor(val+0.5) : -floor(-val+0.5) ); 15: 963-block 0 7: 963-block 1 8: 963-block 2 15: 963-block 3 -: 964:} -: 965: -: 966:/// Main test program 1: 967:int main( const int argc , const char* argv[] ) { 1: 967-block 0 1: 968: printf( "TestCase [mnyfmtts.c]\n" ); 1: 968-block 0 1: 969: assertFalse( 1==2 ); // ok! 1: 970: test_str2mnyCE(); 1: 971: return mnyfmtts(argc , argv); -: 972:} -: 973: -: 974:// EOF: mnyfmtts.c