git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/FreeRTOS-Plus-FAT-SL/fat_sl/test/test.c

   1 /*\r
   2  * FreeRTOS+FAT SL V1.0.1 (C) 2014 HCC Embedded\r
   3  *\r
   4  * The FreeRTOS+FAT SL license terms are different to the FreeRTOS license\r
   5  * terms.\r
   6  *\r
   7  * FreeRTOS+FAT SL uses a dual license model that allows the software to be used\r
   8  * under a standard GPL open source license, or a commercial license.  The\r
   9  * standard GPL license (unlike the modified GPL license under which FreeRTOS\r
  10  * itself is distributed) requires that all software statically linked with\r
  11  * FreeRTOS+FAT SL is also distributed under the same GPL V2 license terms.\r
  12  * Details of both license options follow:\r
  13  *\r
  14  * - Open source licensing -\r
  15  * FreeRTOS+FAT SL is a free download and may be used, modified, evaluated and\r
  16  * distributed without charge provided the user adheres to version two of the\r
  17  * GNU General Public License (GPL) and does not remove the copyright notice or\r
  18  * this text.  The GPL V2 text is available on the gnu.org web site, and on the\r
  19  * following URL: http://www.FreeRTOS.org/gpl-2.0.txt.\r
  20  *\r
  21  * - Commercial licensing -\r
  22  * Businesses and individuals who for commercial or other reasons cannot comply\r
  23  * with the terms of the GPL V2 license must obtain a commercial license before\r
  24  * incorporating FreeRTOS+FAT SL into proprietary software for distribution in\r
  25  * any form.  Commercial licenses can be purchased from\r
  26  * http://shop.freertos.org/fat_sl and do not require any source files to be\r
  27  * changed.\r
  28  *\r
  29  * FreeRTOS+FAT SL is distributed in the hope that it will be useful.  You\r
  30  * cannot use FreeRTOS+FAT SL unless you agree that you use the software 'as\r
  31  * is'.  FreeRTOS+FAT SL is provided WITHOUT ANY WARRANTY; without even the\r
  32  * implied warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A\r
  33  * PARTICULAR PURPOSE. Real Time Engineers Ltd. and HCC Embedded disclaims all\r
  34  * conditions and terms, be they implied, expressed, or statutory.\r
  35  *\r
  36  * http://www.FreeRTOS.org\r
  37  * http://www.FreeRTOS.org/FreeRTOS-Plus\r
  38  *\r
  39  */\r
  40 \r
  41 #include "test.h"\r
  42 #include "../../api/fat_sl.h"\r
  43 #include "config_fat_sl_test.h"\r
  44 #include "../../psp/target/fat_sl/psp_test.h"\r
  45 \r
  46 #include "../../version/ver_fat_sl.h"\r
  47 #if VER_FAT_SL_MAJOR != 5 || VER_FAT_SL_MINOR != 2\r
  48  #error Incompatible FAT_SL version number!\r
  49 #endif\r
  50 \r
  51 static char  cwd[F_MAXPATH];\r
  52 \r
  53 static F_FIND  find;\r
  54 \r
  55 static void _f_deleteall ( void )\r
  56 {\r
  57   F_FIND         f2;\r
  58   unsigned char  sd = 0, rc, fl = 0;\r
  59 \r
  60   f2 = find;\r
  61   do\r
  62   {\r
  63     rc = f_findfirst( "*.*", &find );\r
  64     while ( rc == 0 && find.filename[0] == '.' )\r
  65     {\r
  66       rc = f_findnext( &find );\r
  67     }\r
  68 \r
  69     if ( rc == 0 )\r
  70     {\r
  71       if ( find.attr & F_ATTR_DIR )\r
  72       {\r
  73         ++sd;\r
  74         fl = 1;\r
  75         f2 = find;\r
  76         (void)f_chdir( find.filename );\r
  77         continue;\r
  78       }\r
  79       else\r
  80       {\r
  81         (void)f_delete( find.filename );\r
  82         rc = f_findnext( &find );\r
  83       }\r
  84     }\r
  85 \r
  86     if ( rc && sd && fl )\r
  87     {\r
  88       (void)f_chdir( ".." );\r
  89       --sd;\r
  90       fl = 0;\r
  91       find = f2;\r
  92       (void)f_rmdir( find.filename );\r
  93       rc = f_findnext( &find );\r
  94     }\r
  95 \r
  96     if ( rc && sd && !fl )\r
  97     {\r
  98       (void)f_chdir( "/" );\r
  99       sd = 0;\r
 100       rc = 0;\r
 101     }\r
 102   }\r
 103   while ( rc == 0 );\r
 104 } /* _f_deleteall */\r
 105 \r
 106 char  stmp[20];\r
 107 static char * f_nameconv ( char * s )\r
 108 {\r
 109   char * ss = stmp;\r
 110 \r
 111   for ( ; ; )\r
 112   {\r
 113     char  ch = *s++;\r
 114     if ( ( ch >= 'a' ) && ( ch <= 'z' ) )\r
 115     {\r
 116       ch += 'A' - 'a';\r
 117     }\r
 118 \r
 119     *ss++ = ch;\r
 120     if ( !ch )\r
 121     {\r
 122       break;\r
 123     }\r
 124   }\r
 125 \r
 126   return stmp;\r
 127 } /* f_nameconv */\r
 128 \r
 129 static unsigned char f_formatting ( void )\r
 130 {\r
 131   unsigned char  ret;\r
 132 \r
 133   _f_dump( "f_formatting" );\r
 134 \r
 135 /*checking formatting*/\r
 136   ret = f_format( F_FAT_TYPE );\r
 137   if ( ret )\r
 138   {\r
 139     return _f_result( __LINE__, ret );\r
 140   }\r
 141 \r
 142   ret = _f_poweron();\r
 143   if ( ret )\r
 144   {\r
 145     return _f_result( __LINE__, ret );\r
 146   }\r
 147 \r
 148   ret = f_findfirst( "*.*", &find );\r
 149   if ( ret != F_ERR_NOTFOUND )\r
 150   {\r
 151     return _f_result( __LINE__, ret );\r
 152   }\r
 153 \r
 154   _f_dump( "passed..." );\r
 155   return 0;\r
 156 } /* f_formatting */\r
 157 \r
 158 static unsigned char _f_checkcwd ( char * orig )\r
 159 {\r
 160   unsigned char  ret;\r
 161 \r
 162   ret = f_getcwd( cwd, F_MAXPATH );\r
 163   if ( ret )\r
 164   {\r
 165     return ret;\r
 166   }\r
 167 \r
 168   if ( strcmp( orig, cwd ) )\r
 169   {\r
 170     return (unsigned char)-1;\r
 171   }\r
 172 \r
 173   return 0;\r
 174 }\r
 175 \r
 176 static unsigned char f_dirtest ( void )\r
 177 {\r
 178   unsigned char  ret;\r
 179 \r
 180   _f_dump( "f_dirtest" );\r
 181 \r
 182   _f_deleteall();\r
 183 \r
 184 /*creates a ab abc abcd*/\r
 185   ret = f_mkdir( "a" );\r
 186   if ( ret )\r
 187   {\r
 188     return _f_result( __LINE__, ret );\r
 189   }\r
 190 \r
 191   ret = f_mkdir( "ab" );\r
 192   if ( ret )\r
 193   {\r
 194     return _f_result( __LINE__, ret );\r
 195   }\r
 196 \r
 197   ret = f_mkdir( "abc" );\r
 198   if ( ret )\r
 199   {\r
 200     return _f_result( __LINE__, ret );\r
 201   }\r
 202 \r
 203   ret = f_mkdir( "abca" );\r
 204   if ( ret )\r
 205   {\r
 206     return _f_result( __LINE__, ret );\r
 207   }\r
 208 \r
 209 /*creates directories in /a  -  a ab abc abcd*/\r
 210   ret = f_mkdir( "a/a" );\r
 211   if ( ret )\r
 212   {\r
 213     return _f_result( __LINE__, ret );\r
 214   }\r
 215 \r
 216   ret = f_mkdir( "a/ab" );\r
 217   if ( ret )\r
 218   {\r
 219     return _f_result( __LINE__, ret );\r
 220   }\r
 221 \r
 222   ret = f_mkdir( "a/abc" );\r
 223   if ( ret )\r
 224   {\r
 225     return _f_result( __LINE__, ret );\r
 226   }\r
 227 \r
 228   ret = f_mkdir( "a/abcd" );\r
 229   if ( ret )\r
 230   {\r
 231     return _f_result( __LINE__, ret );\r
 232   }\r
 233 \r
 234 /*change into a/abcd and check cwd*/\r
 235   ret = f_chdir( "a/abcd" );\r
 236   if ( ret )\r
 237   {\r
 238     return _f_result( __LINE__, ret );\r
 239   }\r
 240 \r
 241   ret = _f_checkcwd( f_nameconv( "/a/abcd" ) );\r
 242   if ( ret )\r
 243   {\r
 244     return _f_result( __LINE__, ret );\r
 245   }\r
 246 \r
 247 /*make directory t change into t and check cwd="a/abcd/t"*/\r
 248   ret = f_mkdir( "t" );\r
 249   if ( ret )\r
 250   {\r
 251     return _f_result( __LINE__, ret );\r
 252   }\r
 253 \r
 254   ret = f_chdir( "t" );\r
 255   if ( ret )\r
 256   {\r
 257     return _f_result( __LINE__, ret );\r
 258   }\r
 259 \r
 260   ret = _f_checkcwd( f_nameconv( "/a/abcd/t" ) );\r
 261   if ( ret )\r
 262   {\r
 263     return _f_result( __LINE__, ret );\r
 264   }\r
 265 \r
 266   ret = f_chdir( "." );\r
 267   if ( ret )\r
 268   {\r
 269     return _f_result( __LINE__, ret );\r
 270   }\r
 271 \r
 272   ret = _f_checkcwd( f_nameconv( "/a/abcd/t" ) );\r
 273   if ( ret )\r
 274   {\r
 275     return _f_result( __LINE__, ret );\r
 276   }\r
 277 \r
 278   ret = f_chdir( "../." );\r
 279   if ( ret )\r
 280   {\r
 281     return _f_result( __LINE__, ret );\r
 282   }\r
 283 \r
 284   ret = _f_checkcwd( f_nameconv( "/a/abcd" ) );\r
 285   if ( ret )\r
 286   {\r
 287     return _f_result( __LINE__, ret );\r
 288   }\r
 289 \r
 290 /*removing t dir*/\r
 291   ret = f_rmdir( "t" );\r
 292   if ( ret )\r
 293   {\r
 294     return _f_result( __LINE__, ret );\r
 295   }\r
 296 \r
 297   ret = f_chdir( "t" );\r
 298   if ( ret != F_ERR_NOTFOUND )\r
 299   {\r
 300     return _f_result( __LINE__, ret );\r
 301   }\r
 302 \r
 303 /*removing /a dir*/\r
 304   ret = f_rmdir( "/ab" );\r
 305   if ( ret )\r
 306   {\r
 307     return _f_result( __LINE__, ret );\r
 308   }\r
 309 \r
 310   ret = f_chdir( "/ab" );\r
 311   if ( ret != F_ERR_NOTFOUND )\r
 312   {\r
 313     return _f_result( __LINE__, ret );\r
 314   }\r
 315 \r
 316 /*removing /a dir*/\r
 317   ret = f_rmdir( "../../a" );\r
 318   if ( ret != F_ERR_NOTEMPTY )\r
 319   {\r
 320     return _f_result( __LINE__, ret );\r
 321   }\r
 322 \r
 323 /*removing /abca dir*/\r
 324   ret = f_rmdir( "a:/abca" );\r
 325   if ( ret )\r
 326   {\r
 327     return _f_result( __LINE__, ret );\r
 328   }\r
 329 \r
 330 /*changing invalid dirs*/\r
 331   ret = f_chdir( "" );\r
 332   if ( ret != F_ERR_INVALIDNAME )\r
 333   {\r
 334     return _f_result( __LINE__, ret );\r
 335   }\r
 336 \r
 337   ret = f_chdir( " " );\r
 338   if ( ret )\r
 339   {\r
 340     return _f_result( __LINE__, ret );\r
 341   }\r
 342 \r
 343   ret = _f_checkcwd( f_nameconv( "/a/abcd" ) );\r
 344   if ( ret )\r
 345   {\r
 346     return _f_result( __LINE__, ret );\r
 347   }\r
 348 \r
 349   ret = f_chdir( "?" );\r
 350   if ( ret != F_ERR_INVALIDNAME )\r
 351   {\r
 352     return _f_result( __LINE__, ret );\r
 353   }\r
 354 \r
 355   ret = f_chdir( "*.*" );\r
 356   if ( ret != F_ERR_INVALIDNAME )\r
 357   {\r
 358     return _f_result( __LINE__, ret );\r
 359   }\r
 360 \r
 361   ret = _f_checkcwd( f_nameconv( "/a/abcd" ) );\r
 362   if ( ret )\r
 363   {\r
 364     return _f_result( __LINE__, ret );\r
 365   }\r
 366 \r
 367 /*changing into /abc and removes subfolder from /a/ */\r
 368   ret = f_chdir( "/abc" );\r
 369   if ( ret )\r
 370   {\r
 371     return _f_result( __LINE__, ret );\r
 372   }\r
 373 \r
 374   ret = f_rmdir( "/a/a" );\r
 375   if ( ret )\r
 376   {\r
 377     return _f_result( __LINE__, ret );\r
 378   }\r
 379 \r
 380   ret = f_rmdir( "A:../a/ab" );\r
 381   if ( ret )\r
 382   {\r
 383     return _f_result( __LINE__, ret );\r
 384   }\r
 385 \r
 386   ret = f_rmdir( "A:/a/abc" );\r
 387   if ( ret )\r
 388   {\r
 389     return _f_result( __LINE__, ret );\r
 390   }\r
 391 \r
 392   ret = f_rmdir( ".././abc/.././a/../a/abcd" );\r
 393   if ( ret )\r
 394   {\r
 395     return _f_result( __LINE__, ret );\r
 396   }\r
 397 \r
 398 /*some invalid rmdir*/\r
 399   ret = f_rmdir( "." );\r
 400   if ( ret != F_ERR_NOTFOUND )\r
 401   {\r
 402     return _f_result( __LINE__, ret );\r
 403   }\r
 404 \r
 405   ret = f_rmdir( ".." );\r
 406   if ( ret != F_ERR_NOTFOUND )\r
 407   {\r
 408     return _f_result( __LINE__, ret );\r
 409   }\r
 410 \r
 411 /*create again abc remove abc*/\r
 412   ret = f_mkdir( ".././abc" );\r
 413   if ( ret != F_ERR_DUPLICATED )\r
 414   {\r
 415     return _f_result( __LINE__, ret );\r
 416   }\r
 417 \r
 418   ret = f_rmdir( "../abc" );\r
 419   if ( ret )\r
 420   {\r
 421     return _f_result( __LINE__, ret );\r
 422   }\r
 423 \r
 424   ret = f_mkdir( ".././abc" );\r
 425   if ( ret != F_ERR_INVALIDDIR )\r
 426   {\r
 427     return _f_result( __LINE__, ret );                         /*cwd is not exist*/\r
 428   }\r
 429 \r
 430   ret = f_chdir( "/" );\r
 431   if ( ret )\r
 432   {\r
 433     return _f_result( __LINE__, ret );\r
 434   }\r
 435 \r
 436 /*try . and .. in the root*/\r
 437   ret = f_chdir( "." );\r
 438   if ( ret )\r
 439   {\r
 440     return _f_result( __LINE__, ret );\r
 441   }\r
 442 \r
 443   ret = f_chdir( "./././." );\r
 444   if ( ret )\r
 445   {\r
 446     return _f_result( __LINE__, ret );\r
 447   }\r
 448 \r
 449   ret = f_chdir( ".." );\r
 450   if ( ret != F_ERR_NOTFOUND )\r
 451   {\r
 452     return _f_result( __LINE__, ret );\r
 453   }\r
 454 \r
 455   ret = _f_checkcwd( "/" ); /*root!*/\r
 456   if ( ret )\r
 457   {\r
 458     return _f_result( __LINE__, ret );\r
 459   }\r
 460 \r
 461 /*test . and .. in a and remove a*/\r
 462   ret = f_chdir( "a" );\r
 463   if ( ret )\r
 464   {\r
 465     return _f_result( __LINE__, ret );\r
 466   }\r
 467 \r
 468   ret = f_chdir( ".." );\r
 469   if ( ret )\r
 470   {\r
 471     return _f_result( __LINE__, ret );\r
 472   }\r
 473 \r
 474   ret = f_chdir( "a" );\r
 475   if ( ret )\r
 476   {\r
 477     return _f_result( __LINE__, ret );\r
 478   }\r
 479 \r
 480   ret = f_chdir( "." );\r
 481   if ( ret )\r
 482   {\r
 483     return _f_result( __LINE__, ret );\r
 484   }\r
 485 \r
 486   ret = f_chdir( "a" );\r
 487   if ( ret != F_ERR_NOTFOUND )\r
 488   {\r
 489     return _f_result( __LINE__, ret );\r
 490   }\r
 491 \r
 492   ret = f_chdir( "./.." );\r
 493   if ( ret )\r
 494   {\r
 495     return _f_result( __LINE__, ret );\r
 496   }\r
 497 \r
 498   ret = f_rmdir( "a" );\r
 499   if ( ret )\r
 500   {\r
 501     return _f_result( __LINE__, ret );\r
 502   }\r
 503 \r
 504 /*check if all are removed*/\r
 505   ret = f_findfirst( "*.*", &find );\r
 506   if ( ret != F_ERR_NOTFOUND )\r
 507   {\r
 508     return _f_result( __LINE__, ret );\r
 509   }\r
 510 \r
 511   _f_dump( "passed..." );\r
 512   return 0;\r
 513 } /* f_dirtest */\r
 514 \r
 515 \r
 516 static unsigned char f_findingtest ( void )\r
 517 {\r
 518   unsigned char  ret;\r
 519 \r
 520   _f_dump( "f_findingtest" );\r
 521 \r
 522   _f_deleteall();\r
 523 \r
 524 /*check empty*/\r
 525   ret = f_findfirst( "*.*", &find );\r
 526   if ( ret != F_ERR_NOTFOUND )\r
 527   {\r
 528     return _f_result( __LINE__, ret );\r
 529   }\r
 530 \r
 531 /*create Hello.dir*/\r
 532   ret = f_mkdir( "Hello.dir" );\r
 533   if ( ret )\r
 534   {\r
 535     return _f_result( __LINE__, ret );\r
 536   }\r
 537 \r
 538 /*check if it is exist, and only exist*/\r
 539   ret = f_findfirst( "*.*", &find );\r
 540   if ( ret )\r
 541   {\r
 542     return _f_result( __LINE__, ret );\r
 543   }\r
 544 \r
 545   if ( strcmp( find.filename, f_nameconv( "Hello.dir" ) ) )\r
 546   {\r
 547     return _f_result( __LINE__, 0 );\r
 548   }\r
 549 \r
 550   if ( find.attr != F_ATTR_DIR )\r
 551   {\r
 552     return _f_result( __LINE__, 0 );\r
 553   }\r
 554 \r
 555   ret = f_findnext( &find );\r
 556   if ( ret != F_ERR_NOTFOUND )\r
 557   {\r
 558     return _f_result( __LINE__, ret );\r
 559   }\r
 560 \r
 561 /*check some not founds*/\r
 562   ret = f_findfirst( "q*.*", &find );\r
 563   if ( ret != F_ERR_NOTFOUND )\r
 564   {\r
 565     return _f_result( __LINE__, ret );\r
 566   }\r
 567 \r
 568   ret = f_findfirst( "Hello.", &find );\r
 569   if ( ret != F_ERR_NOTFOUND )\r
 570   {\r
 571     return _f_result( __LINE__, ret );\r
 572   }\r
 573 \r
 574   ret = f_findfirst( "a/*.*", &find );\r
 575   if ( ret != F_ERR_INVALIDDIR )\r
 576   {\r
 577     return _f_result( __LINE__, ret );\r
 578   }\r
 579 \r
 580   ret = f_findfirst( ".", &find );\r
 581   if ( ret != F_ERR_NOTFOUND )\r
 582   {\r
 583     return _f_result( __LINE__, ret );\r
 584   }\r
 585 \r
 586   ret = f_findfirst( "..", &find );\r
 587   if ( ret != F_ERR_NOTFOUND )\r
 588   {\r
 589     return _f_result( __LINE__, ret );\r
 590   }\r
 591 \r
 592   ret = f_findfirst( "?e.*", &find );\r
 593   if ( ret != F_ERR_NOTFOUND )\r
 594   {\r
 595     return _f_result( __LINE__, ret );\r
 596   }\r
 597 \r
 598   ret = f_findfirst( "*.", &find );\r
 599   if ( ret != F_ERR_NOTFOUND )\r
 600   {\r
 601     return _f_result( __LINE__, ret );\r
 602   }\r
 603 \r
 604   ret = f_findfirst( "*.?", &find );\r
 605   if ( ret != F_ERR_NOTFOUND )\r
 606   {\r
 607     return _f_result( __LINE__, ret );\r
 608   }\r
 609 \r
 610   ret = f_findfirst( "*.??", &find );\r
 611   if ( ret != F_ERR_NOTFOUND )\r
 612   {\r
 613     return _f_result( __LINE__, ret );\r
 614   }\r
 615 \r
 616 \r
 617 /*check some founds*/\r
 618   ret = f_findfirst( "*.dir", &find );\r
 619   if ( ret )\r
 620   {\r
 621     return _f_result( __LINE__, ret );\r
 622   }\r
 623 \r
 624   ret = f_findfirst( "*.d?r", &find );\r
 625   if ( ret )\r
 626   {\r
 627     return _f_result( __LINE__, ret );\r
 628   }\r
 629 \r
 630   ret = f_findfirst( "*.d??", &find );\r
 631   if ( ret )\r
 632   {\r
 633     return _f_result( __LINE__, ret );\r
 634   }\r
 635 \r
 636   ret = f_findfirst( "*.???", &find );\r
 637   if ( ret )\r
 638   {\r
 639     return _f_result( __LINE__, ret );\r
 640   }\r
 641 \r
 642   ret = f_findfirst( "?ello.???", &find );\r
 643   if ( ret )\r
 644   {\r
 645     return _f_result( __LINE__, ret );\r
 646   }\r
 647 \r
 648   ret = f_findfirst( "he??o.dir", &find );\r
 649   if ( ret )\r
 650   {\r
 651     return _f_result( __LINE__, ret );\r
 652   }\r
 653 \r
 654   ret = f_findfirst( "he?*.dir", &find );\r
 655   if ( ret )\r
 656   {\r
 657     return _f_result( __LINE__, ret );\r
 658   }\r
 659 \r
 660   ret = f_findfirst( "HELLO.DIR", &find ); /*no capitals sensitivity in find!!*/\r
 661   if ( ret )\r
 662   {\r
 663     return _f_result( __LINE__, ret );\r
 664   }\r
 665 \r
 666 /*change into hello.dir*/\r
 667   ret = f_chdir( "hello.dir" );\r
 668   if ( ret )\r
 669   {\r
 670     return _f_result( __LINE__, ret );\r
 671   }\r
 672 \r
 673   ret = f_findfirst( "*.*", &find );\r
 674   if ( ret )\r
 675   {\r
 676     return _f_result( __LINE__, ret );\r
 677   }\r
 678 \r
 679   ret = f_findfirst( "..", &find );\r
 680   if ( ret )\r
 681   {\r
 682     return _f_result( __LINE__, ret );\r
 683   }\r
 684 \r
 685   ret = f_findfirst( "??", &find );\r
 686   if ( ret )\r
 687   {\r
 688     return _f_result( __LINE__, ret );\r
 689   }\r
 690 \r
 691   ret = f_findfirst( ".", &find );\r
 692   if ( ret )\r
 693   {\r
 694     return _f_result( __LINE__, ret );\r
 695   }\r
 696 \r
 697   ret = f_findfirst( "k*.*", &find );\r
 698   if ( ret != F_ERR_NOTFOUND )\r
 699   {\r
 700     return _f_result( __LINE__, ret );\r
 701   }\r
 702 \r
 703   ret = f_findfirst( "*.", &find );\r
 704   if ( ret )\r
 705   {\r
 706     return _f_result( __LINE__, ret );\r
 707   }\r
 708 \r
 709   if ( strcmp( find.filename, "." ) )\r
 710   {\r
 711     return _f_result( __LINE__, 0 );\r
 712   }\r
 713 \r
 714   ret = f_findnext( &find );\r
 715   if ( ret )\r
 716   {\r
 717     return _f_result( __LINE__, ret );\r
 718   }\r
 719 \r
 720   if ( strcmp( find.filename, ".." ) )\r
 721   {\r
 722     return _f_result( __LINE__, 0 );\r
 723   }\r
 724 \r
 725   ret = f_findnext( &find );\r
 726   if ( ret != F_ERR_NOTFOUND )\r
 727   {\r
 728     return _f_result( __LINE__, ret );\r
 729   }\r
 730 \r
 731 \r
 732   ret = f_findfirst( "*.a", &find );\r
 733   if ( ret != F_ERR_NOTFOUND )\r
 734   {\r
 735     return _f_result( __LINE__, ret );\r
 736   }\r
 737 \r
 738 /*creating testdir and find it*/\r
 739   ret = f_mkdir( "testdir" );\r
 740   if ( ret )\r
 741   {\r
 742     return _f_result( __LINE__, ret );\r
 743   }\r
 744 \r
 745   ret = f_findfirst( "*.", &find );\r
 746   if ( ret )\r
 747   {\r
 748     return _f_result( __LINE__, ret );\r
 749   }\r
 750 \r
 751   if ( strcmp( find.filename, "." ) )\r
 752   {\r
 753     return _f_result( __LINE__, 0 );\r
 754   }\r
 755 \r
 756   ret = f_findnext( &find );\r
 757   if ( ret )\r
 758   {\r
 759     return _f_result( __LINE__, ret );\r
 760   }\r
 761 \r
 762   if ( strcmp( find.filename, ".." ) )\r
 763   {\r
 764     return _f_result( __LINE__, 0 );\r
 765   }\r
 766 \r
 767   ret = f_findnext( &find );\r
 768   if ( ret )\r
 769   {\r
 770     return _f_result( __LINE__, ret );\r
 771   }\r
 772 \r
 773 \r
 774   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
 775   {\r
 776     return _f_result( __LINE__, 0 );\r
 777   }\r
 778 \r
 779   ret = f_findfirst( "*.*", &find );\r
 780   if ( ret )\r
 781   {\r
 782     return _f_result( __LINE__, ret );\r
 783   }\r
 784 \r
 785   if ( strcmp( find.filename, "." ) )\r
 786   {\r
 787     return _f_result( __LINE__, 0 );\r
 788   }\r
 789 \r
 790   ret = f_findnext( &find );\r
 791   if ( ret )\r
 792   {\r
 793     return _f_result( __LINE__, ret );\r
 794   }\r
 795 \r
 796   if ( strcmp( find.filename, ".." ) )\r
 797   {\r
 798     return _f_result( __LINE__, 0 );\r
 799   }\r
 800 \r
 801   ret = f_findnext( &find );\r
 802   if ( ret )\r
 803   {\r
 804     return _f_result( __LINE__, ret );\r
 805   }\r
 806 \r
 807   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
 808   {\r
 809     return _f_result( __LINE__, 0 );\r
 810   }\r
 811 \r
 812   ret = f_findnext( &find );\r
 813   if ( ret != F_ERR_NOTFOUND )\r
 814   {\r
 815     return _f_result( __LINE__, ret );\r
 816   }\r
 817 \r
 818 /*search exact file*/\r
 819   ret = f_findfirst( "testDir", &find ); /*no capitals!*/\r
 820   if ( ret )\r
 821   {\r
 822     return _f_result( __LINE__, ret );\r
 823   }\r
 824 \r
 825   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
 826   {\r
 827     return _f_result( __LINE__, 0 );\r
 828   }\r
 829 \r
 830   ret = f_findnext( &find );\r
 831   if ( ret != F_ERR_NOTFOUND )\r
 832   {\r
 833     return _f_result( __LINE__, ret );\r
 834   }\r
 835 \r
 836 \r
 837 /*go back to root and remove dirs*/\r
 838   ret = f_chdir( "\\" );\r
 839   if ( ret )\r
 840   {\r
 841     return _f_result( __LINE__, ret );\r
 842   }\r
 843 \r
 844   ret = f_rmdir( "Hello.dir/testdir" );\r
 845   if ( ret )\r
 846   {\r
 847     return _f_result( __LINE__, ret );\r
 848   }\r
 849 \r
 850   ret = f_rmdir( "Hello.dir" );\r
 851   if ( ret )\r
 852   {\r
 853     return _f_result( __LINE__, ret );\r
 854   }\r
 855 \r
 856 /*check if all are removed*/\r
 857   ret = f_findfirst( "*.*", &find );\r
 858   if ( ret != F_ERR_NOTFOUND )\r
 859   {\r
 860     return _f_result( __LINE__, ret );\r
 861   }\r
 862 \r
 863   _f_dump( "passed..." );\r
 864   return 0;\r
 865 } /* f_findingtest */\r
 866 \r
 867 static unsigned char f_powerfail ( void )\r
 868 {\r
 869   unsigned char  ret;\r
 870 \r
 871   _f_dump( "f_powerfail" );\r
 872 \r
 873 /*checking if its power fail system (RAMDRIVE is not powerfail!)*/\r
 874   ret = f_mkdir( "testdir" );\r
 875   if ( ret )\r
 876   {\r
 877     return _f_result( __LINE__, ret );\r
 878   }\r
 879 \r
 880   ret = _f_poweron();\r
 881   if ( ret )\r
 882   {\r
 883     return _f_result( __LINE__, ret );\r
 884   }\r
 885 \r
 886   ret = f_findfirst( "testdir", &find );\r
 887   if ( ret )\r
 888   {\r
 889     return _f_result( __LINE__, ret );\r
 890   }\r
 891 \r
 892 /*checking formatting*/\r
 893   ret = f_format( F_FAT_TYPE );\r
 894   if ( ret )\r
 895   {\r
 896     return _f_result( __LINE__, ret );\r
 897   }\r
 898 \r
 899   ret = _f_poweron();\r
 900   if ( ret )\r
 901   {\r
 902     return _f_result( __LINE__, ret );\r
 903   }\r
 904 \r
 905   ret = f_findfirst( "*.*", &find );\r
 906   if ( ret != F_ERR_NOTFOUND )\r
 907   {\r
 908     return _f_result( __LINE__, ret );\r
 909   }\r
 910 \r
 911 /*checking formatting, 1st creating*/\r
 912   ret = f_format( F_FAT_TYPE );\r
 913   if ( ret )\r
 914   {\r
 915     return _f_result( __LINE__, ret );\r
 916   }\r
 917 \r
 918   ret = f_mkdir( "testdir" );\r
 919   if ( ret )\r
 920   {\r
 921     return _f_result( __LINE__, ret );\r
 922   }\r
 923 \r
 924   ret = f_findfirst( "testdir", &find );\r
 925   if ( ret )\r
 926   {\r
 927     return _f_result( __LINE__, ret );\r
 928   }\r
 929 \r
 930   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
 931   {\r
 932     return _f_result( __LINE__, 0 );\r
 933   }\r
 934 \r
 935   ret = _f_poweron();\r
 936   if ( ret )\r
 937   {\r
 938     return _f_result( __LINE__, ret );\r
 939   }\r
 940 \r
 941   ret = f_findfirst( "*.*", &find );\r
 942   if ( ret )\r
 943   {\r
 944     return _f_result( __LINE__, ret );\r
 945   }\r
 946 \r
 947   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
 948   {\r
 949     return _f_result( __LINE__, 0 );\r
 950   }\r
 951 \r
 952 /*checking formatting, 2nd creating*/\r
 953   ret = f_format( F_FAT_TYPE );\r
 954   if ( ret )\r
 955   {\r
 956     return _f_result( __LINE__, ret );\r
 957   }\r
 958 \r
 959   ret = f_mkdir( "testdir" );\r
 960   if ( ret )\r
 961   {\r
 962     return _f_result( __LINE__, ret );\r
 963   }\r
 964 \r
 965   ret = f_findfirst( "testdir", &find );\r
 966   if ( ret )\r
 967   {\r
 968     return _f_result( __LINE__, ret );\r
 969   }\r
 970 \r
 971   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
 972   {\r
 973     return _f_result( __LINE__, 0 );\r
 974   }\r
 975 \r
 976   ret = f_mkdir( "testdir2" );\r
 977   if ( ret )\r
 978   {\r
 979     return _f_result( __LINE__, ret );\r
 980   }\r
 981 \r
 982   ret = f_findfirst( "testdir2", &find );\r
 983   if ( ret )\r
 984   {\r
 985     return _f_result( __LINE__, ret );\r
 986   }\r
 987 \r
 988   if ( strcmp( find.filename, f_nameconv( "testdir2" ) ) )\r
 989   {\r
 990     return _f_result( __LINE__, 0 );\r
 991   }\r
 992 \r
 993   ret = _f_poweron();\r
 994   if ( ret )\r
 995   {\r
 996     return _f_result( __LINE__, ret );\r
 997   }\r
 998 \r
 999   ret = f_findfirst( "*.*", &find );\r
1000   if ( ret )\r
1001   {\r
1002     return _f_result( __LINE__, ret );\r
1003   }\r
1004 \r
1005   if ( strcmp( find.filename, f_nameconv( "testdir" ) ) )\r
1006   {\r
1007     return _f_result( __LINE__, 0 );\r
1008   }\r
1009 \r
1010   ret = f_findnext( &find );\r
1011   if ( ret )\r
1012   {\r
1013     return _f_result( __LINE__, ret );\r
1014   }\r
1015 \r
1016   if ( strcmp( find.filename, f_nameconv( "testdir2" ) ) )\r
1017   {\r
1018     return _f_result( __LINE__, 0 );\r
1019   }\r
1020 \r
1021   ret = f_findnext( &find );\r
1022   if ( ret != F_ERR_NOTFOUND )\r
1023   {\r
1024     return _f_result( __LINE__, ret );\r
1025   }\r
1026 \r
1027 \r
1028 /*checking empty*/\r
1029   ret = _f_poweron();\r
1030   if ( ret )\r
1031   {\r
1032     return _f_result( __LINE__, ret );\r
1033   }\r
1034 \r
1035   ret = f_format( F_FAT_TYPE );\r
1036   if ( ret )\r
1037   {\r
1038     return _f_result( __LINE__, ret );\r
1039   }\r
1040 \r
1041   ret = _f_poweron();\r
1042   if ( ret )\r
1043   {\r
1044     return _f_result( __LINE__, ret );\r
1045   }\r
1046 \r
1047   ret = f_findfirst( "*.*", &find );\r
1048   if ( ret != F_ERR_NOTFOUND )\r
1049   {\r
1050     return _f_result( __LINE__, ret );\r
1051   }\r
1052 \r
1053 \r
1054   _f_dump( "passed..." );\r
1055   return 0;\r
1056 } /* f_powerfail */\r
1057 \r
1058 \r
1059 char  testbuffer[F_MAX_SEEK_TEST + 16]; /* +16 for f_appending test */\r
1060 \r
1061 static unsigned char checkfilecontent ( long nums, unsigned char value, F_FILE * file )\r
1062 {\r
1063   unsigned char  ch;\r
1064 \r
1065   while ( nums-- )\r
1066   {\r
1067     if ( f_eof( file ) )\r
1068     {\r
1069       return 1;                    /*eof ?*/\r
1070     }\r
1071 \r
1072     if ( 1 != f_read( &ch, 1, 1, file ) )\r
1073     {\r
1074       return 1;\r
1075     }\r
1076 \r
1077     if ( ch != value )\r
1078     {\r
1079       return 1;\r
1080     }\r
1081   }\r
1082 \r
1083   return 0;\r
1084 } /* checkfilecontent */\r
1085 \r
1086 static unsigned char f_seeking ( int sectorsize )\r
1087 {\r
1088   F_FILE       * file;\r
1089   unsigned char  ret;\r
1090   unsigned long  size;\r
1091   unsigned long  pos;\r
1092   unsigned long  fname_pos;\r
1093   char         * test_fname[4] =\r
1094   {\r
1095     "test1.txt", "test2.txt", "test3.txt", "test4.txt"\r
1096   };\r
1097 \r
1098   if ( sectorsize == 128 )\r
1099   {\r
1100     _f_dump( "f_seeking with 128" );\r
1101   }\r
1102 \r
1103 #if ( F_MAX_SEEK_TEST > 128 )\r
1104   else if ( sectorsize == 256 )\r
1105   {\r
1106     _f_dump( "f_seeking with 256" );\r
1107   }\r
1108 #endif\r
1109 #if ( F_MAX_SEEK_TEST > 256 )\r
1110   else if ( sectorsize == 512 )\r
1111   {\r
1112     _f_dump( "f_seeking with 512" );\r
1113   }\r
1114 #endif\r
1115 #if ( F_MAX_SEEK_TEST > 512 )\r
1116   else if ( sectorsize == 1024 )\r
1117   {\r
1118     _f_dump( "f_seeking with 1024" );\r
1119   }\r
1120 #endif\r
1121 #if ( F_MAX_SEEK_TEST > 1024 )\r
1122   else if ( sectorsize == 2048 )\r
1123   {\r
1124     _f_dump( "f_seeking with 2048" );\r
1125   }\r
1126 #endif\r
1127 #if ( F_MAX_SEEK_TEST > 2048 )\r
1128   else if ( sectorsize == 4096 )\r
1129   {\r
1130     _f_dump( "f_seeking with 4096" );\r
1131   }\r
1132 #endif\r
1133 #if ( F_MAX_SEEK_TEST > 4096 )\r
1134   else if ( sectorsize == 8192 )\r
1135   {\r
1136     _f_dump( "f_seeking with 8192" );\r
1137   }\r
1138 #endif\r
1139 #if ( F_MAX_SEEK_TEST > 8192 )\r
1140   else if ( sectorsize == 16384 )\r
1141   {\r
1142     _f_dump( "f_seeking with 16384" );\r
1143   }\r
1144 #endif\r
1145 #if ( F_MAX_SEEK_TEST > 16384 )\r
1146   else if ( sectorsize == 32768 )\r
1147   {\r
1148     _f_dump( "f_seeking with 32768" );\r
1149   }\r
1150 #endif\r
1151   else\r
1152   {\r
1153     _f_dump( "f_seeking with random" );\r
1154   }\r
1155 \r
1156 /*checking sector boundary seekeng*/\r
1157   file = f_open( "test.bin", "w+" );\r
1158   if ( !file )\r
1159   {\r
1160     return _f_result( __LINE__, 0 );\r
1161   }\r
1162 \r
1163 /*write sectorsize times 0*/\r
1164   psp_memset( testbuffer, 0, sectorsize );\r
1165   size = (unsigned long)f_write( testbuffer, 1, (long)sectorsize, file );\r
1166   if ( size != (unsigned long)sectorsize )\r
1167   {\r
1168     return _f_result( __LINE__, size );\r
1169   }\r
1170 \r
1171   pos = (unsigned long)f_tell( file );\r
1172   if ( pos != (unsigned long)sectorsize )\r
1173   {\r
1174     return _f_result( __LINE__, pos );\r
1175   }\r
1176 \r
1177 /*seek back and read some*/\r
1178   ret = f_seek( file, 0, F_SEEK_SET ); /*seek back*/\r
1179   if ( ret )\r
1180   {\r
1181     return _f_result( __LINE__, ret );\r
1182   }\r
1183 \r
1184   pos = (unsigned long)f_tell( file );\r
1185   if ( pos )\r
1186   {\r
1187     return _f_result( __LINE__, pos );\r
1188   }\r
1189 \r
1190   size = (unsigned long)f_read( testbuffer, 1, sectorsize, file );\r
1191   if ( size != (unsigned long)sectorsize )\r
1192   {\r
1193     return _f_result( __LINE__, size );\r
1194   }\r
1195 \r
1196   pos = (unsigned long)f_tell( file );\r
1197   if ( pos != (unsigned long)sectorsize )\r
1198   {\r
1199     return _f_result( __LINE__, pos );\r
1200   }\r
1201 \r
1202 /*fake read at eof*/\r
1203   size = (unsigned long)f_read( testbuffer, 1, 2, file ); /*eof!*/\r
1204   if ( size != 0 )\r
1205   {\r
1206     return _f_result( __LINE__, size );\r
1207   }\r
1208 \r
1209   pos = (unsigned long)f_tell( file );\r
1210   if ( pos != (unsigned long)sectorsize )\r
1211   {\r
1212     return _f_result( __LINE__, pos );\r
1213   }\r
1214 \r
1215 /*writing sectorsize times 1 at the end*/\r
1216   psp_memset( testbuffer, 1, sectorsize );\r
1217   size = (unsigned long)f_write( testbuffer, 1, sectorsize, file );\r
1218   if ( size != (unsigned long)sectorsize )\r
1219   {\r
1220     return _f_result( __LINE__, size );\r
1221   }\r
1222 \r
1223   pos = (unsigned long)f_tell( file );\r
1224   if ( pos != (unsigned long)( sectorsize * 2 ) )\r
1225   {\r
1226     return _f_result( __LINE__, pos );\r
1227   }\r
1228 \r
1229 /*seeking back and read 1byte less*/\r
1230   ret = f_seek( file, 0, F_SEEK_SET );\r
1231   if ( ret )\r
1232   {\r
1233     return _f_result( __LINE__, ret );\r
1234   }\r
1235 \r
1236   pos = (unsigned long)f_tell( file );\r
1237   if ( pos )\r
1238   {\r
1239     return _f_result( __LINE__, pos );\r
1240   }\r
1241 \r
1242   size = (unsigned long)f_read( testbuffer, 1, sectorsize - 1, file );\r
1243   if ( size != (unsigned long)( sectorsize - 1 ) )\r
1244   {\r
1245     return _f_result( __LINE__, size );\r
1246   }\r
1247 \r
1248   pos = (unsigned long)f_tell( file );\r
1249   if ( pos != (unsigned long)( sectorsize - 1 ) )\r
1250   {\r
1251     return _f_result( __LINE__, pos );\r
1252   }\r
1253 \r
1254 \r
1255 /*write 2 times 2*/\r
1256   psp_memset( testbuffer, 2, sectorsize );\r
1257   size = (unsigned long)f_write( testbuffer, 1, 2, file );\r
1258   if ( size != 2 )\r
1259   {\r
1260     return _f_result( __LINE__, size );\r
1261   }\r
1262 \r
1263   pos = (unsigned long)f_tell( file );\r
1264   if ( pos != (unsigned long)( sectorsize + 1 ) )\r
1265   {\r
1266     return _f_result( __LINE__, pos );\r
1267   }\r
1268 \r
1269 /*read 2 bytes*/\r
1270   size = (unsigned long)f_read( testbuffer, 2, 1, file );\r
1271   if ( size != 1 )\r
1272   {\r
1273     return _f_result( __LINE__, size );\r
1274   }\r
1275 \r
1276   pos = (unsigned long)f_tell( file );\r
1277   if ( pos != (unsigned long)( sectorsize + 3 ) )\r
1278   {\r
1279     return _f_result( __LINE__, pos );\r
1280   }\r
1281 \r
1282 \r
1283 /*write 4 times 3*/\r
1284   psp_memset( testbuffer, 3, sectorsize );\r
1285   size = (unsigned long)f_write( testbuffer, 1, 4, file );\r
1286   if ( size != 4 )\r
1287   {\r
1288     return _f_result( __LINE__, size );\r
1289   }\r
1290 \r
1291   pos = (unsigned long)f_tell( file );\r
1292   if ( pos != (unsigned long)( sectorsize + 3 + 4 ) )\r
1293   {\r
1294     return _f_result( __LINE__, pos );\r
1295   }\r
1296 \r
1297 /*seek at 2*/\r
1298   ret = f_seek( file, 2, F_SEEK_SET );\r
1299   if ( ret )\r
1300   {\r
1301     return _f_result( __LINE__, ret );\r
1302   }\r
1303 \r
1304   pos = (unsigned long)f_tell( file );\r
1305   if ( pos != 2 )\r
1306   {\r
1307     return _f_result( __LINE__, pos );\r
1308   }\r
1309 \r
1310 /*write 6 times 4*/\r
1311   psp_memset( testbuffer, 4, sectorsize );\r
1312   size = (unsigned long)f_write( testbuffer, 1, 6, file );\r
1313   if ( size != 6 )\r
1314   {\r
1315     return _f_result( __LINE__, size );\r
1316   }\r
1317 \r
1318   pos = (unsigned long)f_tell( file );\r
1319   if ( pos != 8 )\r
1320   {\r
1321     return _f_result( __LINE__, pos );\r
1322   }\r
1323 \r
1324 /*seek end -4*/\r
1325   ret = f_seek( file, -4, F_SEEK_END );\r
1326   if ( ret )\r
1327   {\r
1328     return _f_result( __LINE__, ret );\r
1329   }\r
1330 \r
1331   pos = (unsigned long)f_tell( file );\r
1332   if ( pos != (unsigned long)( 2 * sectorsize - 4 ) )\r
1333   {\r
1334     return _f_result( __LINE__, pos );\r
1335   }\r
1336 \r
1337 /*read 2 bytes*/\r
1338   size = (unsigned long)f_read( testbuffer, 1, 2, file );\r
1339   if ( size != 2 )\r
1340   {\r
1341     return _f_result( __LINE__, size );\r
1342   }\r
1343 \r
1344   pos = (unsigned long)f_tell( file );\r
1345   if ( pos != (unsigned long)( 2 * sectorsize - 2 ) )\r
1346   {\r
1347     return _f_result( __LINE__, pos );\r
1348   }\r
1349 \r
1350 /*write 8 times 5*/\r
1351   psp_memset( testbuffer, 5, sectorsize );\r
1352   size = (unsigned long)f_write( testbuffer, 1, 8, file );\r
1353   if ( size != 8 )\r
1354   {\r
1355     return _f_result( __LINE__, size );\r
1356   }\r
1357 \r
1358   pos = (unsigned long)f_tell( file );\r
1359   if ( pos != (unsigned long)( 2 * sectorsize + 6 ) )\r
1360   {\r
1361     return _f_result( __LINE__, pos );\r
1362   }\r
1363 \r
1364 /*seek to the begining*/\r
1365   ret = f_seek( file, 0, F_SEEK_SET );\r
1366   if ( ret )\r
1367   {\r
1368     return _f_result( __LINE__, ret );\r
1369   }\r
1370 \r
1371   pos = (unsigned long)f_tell( file );\r
1372   if ( pos )\r
1373   {\r
1374     return _f_result( __LINE__, pos );\r
1375   }\r
1376 \r
1377 /*seek to the end*/\r
1378   ret = f_seek( file, 2 * sectorsize + 6, F_SEEK_SET );\r
1379   if ( ret )\r
1380   {\r
1381     return _f_result( __LINE__, ret );\r
1382   }\r
1383 \r
1384   pos = (unsigned long)f_tell( file );\r
1385   if ( pos != (unsigned long)( 2 * sectorsize + 6 ) )\r
1386   {\r
1387     return _f_result( __LINE__, pos );\r
1388   }\r
1389 \r
1390 /*write 2 times 6*/\r
1391   psp_memset( testbuffer, 6, sectorsize );\r
1392   size = (unsigned long)f_write( testbuffer, 1, 2, file );\r
1393   if ( size != 2 )\r
1394   {\r
1395     return _f_result( __LINE__, size );\r
1396   }\r
1397 \r
1398   pos = (unsigned long)f_tell( file );\r
1399   if ( pos != (unsigned long)( 2 * sectorsize + 8 ) )\r
1400   {\r
1401     return _f_result( __LINE__, pos );\r
1402   }\r
1403 \r
1404 /*seek to the begining*/\r
1405   (void)f_seek( file, -( 2 * sectorsize + 8 ), F_SEEK_CUR );\r
1406   if ( ret )\r
1407   {\r
1408     return _f_result( __LINE__, ret );\r
1409   }\r
1410 \r
1411   pos = (unsigned long)f_tell( file );\r
1412   if ( pos )\r
1413   {\r
1414     return _f_result( __LINE__, pos );\r
1415   }\r
1416 \r
1417 /*read 2 times sector*/\r
1418   size = (unsigned long)f_read( testbuffer, 1, sectorsize, file );\r
1419   if ( size != (unsigned long)sectorsize )\r
1420   {\r
1421     return _f_result( __LINE__, size );\r
1422   }\r
1423 \r
1424   pos = (unsigned long)f_tell( file );\r
1425   if ( pos != (unsigned long)sectorsize )\r
1426   {\r
1427     return _f_result( __LINE__, pos );\r
1428   }\r
1429 \r
1430   size = (unsigned long)f_read( testbuffer, 1, sectorsize, file );\r
1431   if ( size != (unsigned long)sectorsize )\r
1432   {\r
1433     return _f_result( __LINE__, size );\r
1434   }\r
1435 \r
1436   pos = (unsigned long)f_tell( file );\r
1437   if ( pos != (unsigned long)( 2 * sectorsize ) )\r
1438   {\r
1439     return _f_result( __LINE__, pos );\r
1440   }\r
1441 \r
1442 /*write 1 once 7*/\r
1443   psp_memset( testbuffer, 7, sectorsize );\r
1444   size = (unsigned long)f_write( testbuffer, 1, 1, file );\r
1445   if ( size != 1 )\r
1446   {\r
1447     return _f_result( __LINE__, size );\r
1448   }\r
1449 \r
1450   pos = (unsigned long)f_tell( file );\r
1451   if ( pos != (unsigned long)( 2 * sectorsize + 1 ) )\r
1452   {\r
1453     return _f_result( __LINE__, pos );\r
1454   }\r
1455 \r
1456 /*close it*/\r
1457   ret = f_close( file );\r
1458   if ( ret )\r
1459   {\r
1460     return _f_result( __LINE__, ret );\r
1461   }\r
1462 \r
1463 \r
1464 /*check the result*/\r
1465   size = (unsigned long)f_filelength( "test.bin" );\r
1466   if ( size != (unsigned long)( 2 * sectorsize + 8 ) )\r
1467   {\r
1468     return _f_result( __LINE__, size );\r
1469   }\r
1470 \r
1471 /*opens it*/\r
1472   file = f_open( "test.bin", "r" );\r
1473   if ( !file )\r
1474   {\r
1475     return _f_result( __LINE__, size );\r
1476   }\r
1477 \r
1478   if ( checkfilecontent( 2, 0, file ) )\r
1479   {\r
1480     return _f_result( __LINE__, 0 );\r
1481   }\r
1482 \r
1483   if ( checkfilecontent( 6, 4, file ) )\r
1484   {\r
1485     return _f_result( __LINE__, 0 );\r
1486   }\r
1487 \r
1488   if ( checkfilecontent( sectorsize - 8 - 1, 0, file ) )\r
1489   {\r
1490     return _f_result( __LINE__, 0 );\r
1491   }\r
1492 \r
1493   if ( checkfilecontent( 2, 2, file ) )\r
1494   {\r
1495     return _f_result( __LINE__, 0 );\r
1496   }\r
1497 \r
1498   if ( checkfilecontent( 2, 1, file ) )\r
1499   {\r
1500     return _f_result( __LINE__, 0 );\r
1501   }\r
1502 \r
1503   if ( checkfilecontent( 4, 3, file ) )\r
1504   {\r
1505     return _f_result( __LINE__, 0 );\r
1506   }\r
1507 \r
1508   if ( checkfilecontent( sectorsize - 7 - 2, 1, file ) )\r
1509   {\r
1510     return _f_result( __LINE__, 0 );\r
1511   }\r
1512 \r
1513   if ( checkfilecontent( 2, 5, file ) )\r
1514   {\r
1515     return _f_result( __LINE__, 0 );\r
1516   }\r
1517 \r
1518   if ( checkfilecontent( 1, 7, file ) )\r
1519   {\r
1520     return _f_result( __LINE__, 0 );\r
1521   }\r
1522 \r
1523   if ( checkfilecontent( 5, 5, file ) )\r
1524   {\r
1525     return _f_result( __LINE__, 0 );\r
1526   }\r
1527 \r
1528   if ( checkfilecontent( 2, 6, file ) )\r
1529   {\r
1530     return _f_result( __LINE__, 0 );\r
1531   }\r
1532 \r
1533 /*check pos result*/\r
1534   pos = (unsigned long)f_tell( file );\r
1535   if ( pos != (unsigned long)( 2 * sectorsize + 8 ) )\r
1536   {\r
1537     return _f_result( __LINE__, pos );\r
1538   }\r
1539 \r
1540 /*this has to be eof*/\r
1541   pos = f_eof( file );\r
1542   if ( !pos )\r
1543   {\r
1544     return _f_result( __LINE__, pos );\r
1545   }\r
1546 \r
1547 /*close it*/\r
1548   ret = f_close( file );\r
1549   if ( ret )\r
1550   {\r
1551     return _f_result( __LINE__, ret );\r
1552   }\r
1553 \r
1554 /*deletes it*/\r
1555   ret = f_delete( "test.bin" );\r
1556   if ( ret )\r
1557   {\r
1558     return _f_result( __LINE__, ret );\r
1559   }\r
1560 \r
1561   /**************************************************************/\r
1562   for ( pos = 0 ; pos < 4 ; pos++ )\r
1563   {\r
1564     file = f_open( test_fname[pos], "w" );\r
1565     if ( file == NULL )\r
1566     {\r
1567       return _f_result( __LINE__, 0 );\r
1568     }\r
1569 \r
1570     memset( testbuffer, '0' + pos, sectorsize );\r
1571     if ( f_write( testbuffer, 1, sectorsize - 1, file ) != ( sectorsize - 1 ) )\r
1572     {\r
1573       return _f_result( __LINE__, 0 );\r
1574     }\r
1575 \r
1576     ret = f_close( file );\r
1577     if ( ret != F_NO_ERROR )\r
1578     {\r
1579       return _f_result( __LINE__, 0 );\r
1580     }\r
1581   }\r
1582 \r
1583   ret = f_delete( test_fname[0] );\r
1584   if ( ret != F_NO_ERROR )\r
1585   {\r
1586     return _f_result( __LINE__, ret );\r
1587   }\r
1588 \r
1589   ret = f_delete( test_fname[2] );\r
1590   if ( ret != F_NO_ERROR )\r
1591   {\r
1592     return _f_result( __LINE__, ret );\r
1593   }\r
1594 \r
1595   file = f_open( "test.txt", "w" );\r
1596   if ( file == NULL )\r
1597   {\r
1598     return _f_result( __LINE__, 0 );\r
1599   }\r
1600 \r
1601   memset( testbuffer, 'a', sectorsize );\r
1602   if ( f_write( testbuffer, 1, sectorsize, file ) != sectorsize )\r
1603   {\r
1604     return _f_result( __LINE__, 0 );\r
1605   }\r
1606 \r
1607   ret = f_close( file );\r
1608   if ( ret != F_NO_ERROR )\r
1609   {\r
1610     return _f_result( __LINE__, 0 );\r
1611   }\r
1612 \r
1613   file = f_open( "test.txt", "r+" );\r
1614   if ( file == NULL )\r
1615   {\r
1616     return _f_result( __LINE__, 0 );\r
1617   }\r
1618 \r
1619   ret = f_seek( file, 2 * sectorsize, F_SEEK_SET );\r
1620   if ( ret != F_NO_ERROR )\r
1621   {\r
1622     return _f_result( __LINE__, ret );\r
1623   }\r
1624 \r
1625   ret = f_close( file );\r
1626   if ( ret != F_NO_ERROR )\r
1627   {\r
1628     return _f_result( __LINE__, 0 );\r
1629   }\r
1630 \r
1631   for ( pos = 0 ; pos < 2 ; pos++ )\r
1632   {\r
1633     file = f_open( "test.txt", "r+" );\r
1634     if ( file == NULL )\r
1635     {\r
1636       return _f_result( __LINE__, 0 );\r
1637     }\r
1638 \r
1639     ret = f_seek( file, ( pos + 2 ) * sectorsize, F_SEEK_SET );\r
1640     if ( ret != F_NO_ERROR )\r
1641     {\r
1642       return _f_result( __LINE__, ret );\r
1643     }\r
1644 \r
1645     memset( testbuffer, 'b' + pos, sectorsize );\r
1646     if ( f_write( testbuffer, 1, sectorsize, file ) != sectorsize )\r
1647     {\r
1648       return _f_result( __LINE__, 0 );\r
1649     }\r
1650 \r
1651     ret = f_close( file );\r
1652     if ( ret != F_NO_ERROR )\r
1653     {\r
1654       return _f_result( __LINE__, ret );\r
1655     }\r
1656   }\r
1657 \r
1658   fname_pos = 1;\r
1659   for ( pos = 0 ; pos < 2 ; pos++ )\r
1660   {\r
1661     file = f_open( test_fname[fname_pos], "r" );\r
1662     if ( file == NULL )\r
1663     {\r
1664       return _f_result( __LINE__, 0 );\r
1665     }\r
1666 \r
1667     if ( checkfilecontent( sectorsize - 1, '0' + ( unsigned char ) fname_pos, file ) )\r
1668     {\r
1669       return _f_result( __LINE__, 0 );\r
1670     }\r
1671 \r
1672     ret = f_close( file );\r
1673     if ( ret != F_NO_ERROR )\r
1674     {\r
1675       return _f_result( __LINE__, ret );\r
1676     }\r
1677 \r
1678     fname_pos = 3;\r
1679   }\r
1680 \r
1681   file = f_open( "test.txt", "r" );\r
1682   if ( file == NULL )\r
1683   {\r
1684     return _f_result( __LINE__, 0 );\r
1685   }\r
1686 \r
1687   if ( checkfilecontent( sectorsize, 'a', file ) )\r
1688   {\r
1689     return _f_result( __LINE__, 0 );\r
1690   }\r
1691 \r
1692   if ( checkfilecontent( sectorsize, 0, file ) )\r
1693   {\r
1694     return _f_result( __LINE__, 0 );\r
1695   }\r
1696 \r
1697   if ( checkfilecontent( sectorsize, 'b', file ) )\r
1698   {\r
1699     return _f_result( __LINE__, 0 );\r
1700   }\r
1701 \r
1702   if ( checkfilecontent( sectorsize, 'c', file ) )\r
1703   {\r
1704     return _f_result( __LINE__, 0 );\r
1705   }\r
1706 \r
1707   ret = f_close( file );\r
1708   if ( ret != F_NO_ERROR )\r
1709   {\r
1710     return _f_result( __LINE__, ret );\r
1711   }\r
1712 \r
1713   ret = f_delete( "test.txt" );\r
1714   if ( ret != F_NO_ERROR )\r
1715   {\r
1716     return _f_result( __LINE__, ret );\r
1717   }\r
1718 \r
1719   /************************************/\r
1720   file = f_open( "test.txt", "w" );\r
1721   if ( file == NULL )\r
1722   {\r
1723     return _f_result( __LINE__, 0 );\r
1724   }\r
1725 \r
1726   ret = f_seek( file, sectorsize - 2, F_SEEK_SET );\r
1727   if ( ret != F_NO_ERROR )\r
1728   {\r
1729     return _f_result( __LINE__, 0 );\r
1730   }\r
1731 \r
1732   ret = f_close( file );\r
1733   if ( ret != F_NO_ERROR )\r
1734   {\r
1735     return _f_result( __LINE__, 0 );\r
1736   }\r
1737 \r
1738   file = f_open( "test.txt", "r+" );\r
1739   if ( file == NULL )\r
1740   {\r
1741     return _f_result( __LINE__, 0 );\r
1742   }\r
1743 \r
1744   memset( testbuffer, 'f', 2 );\r
1745   if ( f_write( testbuffer, 1, 2, file ) != 2 )\r
1746   {\r
1747     return _f_result( __LINE__, 0 );\r
1748   }\r
1749 \r
1750   ret = f_seek( file, sectorsize - 2, F_SEEK_SET );\r
1751   if ( ret != F_NO_ERROR )\r
1752   {\r
1753     return _f_result( __LINE__, 0 );\r
1754   }\r
1755 \r
1756   memset( testbuffer, 'g', 3 );\r
1757   if ( f_write( testbuffer, 1, 3, file ) != 3 )\r
1758   {\r
1759     return _f_result( __LINE__, 0 );\r
1760   }\r
1761 \r
1762   ret = f_close( file );\r
1763   if ( ret != F_NO_ERROR )\r
1764   {\r
1765     return _f_result( __LINE__, 0 );\r
1766   }\r
1767 \r
1768   file = f_open( "test.txt", "r+" );\r
1769   if ( file == NULL )\r
1770   {\r
1771     return _f_result( __LINE__, 0 );\r
1772   }\r
1773 \r
1774   ret = f_seek( file, sectorsize * 2, F_SEEK_SET );\r
1775   if ( ret != F_NO_ERROR )\r
1776   {\r
1777     return _f_result( __LINE__, 0 );\r
1778   }\r
1779 \r
1780   memset( testbuffer, 'h', sectorsize );\r
1781   if ( f_write( testbuffer, 1, sectorsize, file ) != sectorsize )\r
1782   {\r
1783     return _f_result( __LINE__, 0 );\r
1784   }\r
1785 \r
1786   ret = f_close( file );\r
1787   if ( ret != F_NO_ERROR )\r
1788   {\r
1789     return _f_result( __LINE__, 0 );\r
1790   }\r
1791 \r
1792   size = f_filelength( "test.txt" );\r
1793   if ( size != ( unsigned long ) ( 3 * sectorsize ) )\r
1794   {\r
1795     return _f_result( __LINE__, size );\r
1796   }\r
1797 \r
1798   fname_pos = 1;\r
1799   for ( pos = 0 ; pos < 2 ; pos++ )\r
1800   {\r
1801     file = f_open( test_fname[fname_pos], "r" );\r
1802     if ( file == NULL )\r
1803     {\r
1804       return _f_result( __LINE__, 0 );\r
1805     }\r
1806 \r
1807     if ( checkfilecontent( sectorsize - 1, '0' + ( unsigned char ) fname_pos, file ) )\r
1808     {\r
1809       return _f_result( __LINE__, 0 );\r
1810     }\r
1811 \r
1812     ret = f_close( file );\r
1813     if ( ret != F_NO_ERROR )\r
1814     {\r
1815       return _f_result( __LINE__, ret );\r
1816     }\r
1817 \r
1818     fname_pos = 3;\r
1819   }\r
1820 \r
1821   file = f_open( "test.txt", "r" );\r
1822   if ( file == NULL )\r
1823   {\r
1824     return _f_result( __LINE__, 0 );\r
1825   }\r
1826 \r
1827   if ( checkfilecontent( 2, 'f', file ) )\r
1828   {\r
1829     return _f_result( __LINE__, 0 );\r
1830   }\r
1831 \r
1832   if ( checkfilecontent( sectorsize - 4, 0, file ) )\r
1833   {\r
1834     return _f_result( __LINE__, 0 );\r
1835   }\r
1836 \r
1837   if ( checkfilecontent( 3, 'g', file ) )\r
1838   {\r
1839     return _f_result( __LINE__, 0 );\r
1840   }\r
1841 \r
1842   if ( checkfilecontent( sectorsize - 1, 0, file ) )\r
1843   {\r
1844     return _f_result( __LINE__, 0 );\r
1845   }\r
1846 \r
1847   if ( checkfilecontent( sectorsize, 'h', file ) )\r
1848   {\r
1849     return _f_result( __LINE__, 0 );\r
1850   }\r
1851 \r
1852   ret = f_close( file );\r
1853   if ( ret != F_NO_ERROR )\r
1854   {\r
1855     return _f_result( __LINE__, ret );\r
1856   }\r
1857 \r
1858   ret = f_delete( "test.txt" );\r
1859   if ( ret != F_NO_ERROR )\r
1860   {\r
1861     return _f_result( __LINE__, ret );\r
1862   }\r
1863 \r
1864   ret = f_delete( test_fname[1] );\r
1865   if ( ret != F_NO_ERROR )\r
1866   {\r
1867     return _f_result( __LINE__, ret );\r
1868   }\r
1869 \r
1870   ret = f_delete( test_fname[3] );\r
1871   if ( ret != F_NO_ERROR )\r
1872   {\r
1873     return _f_result( __LINE__, ret );\r
1874   }\r
1875 \r
1876   _f_dump( "passed..." );\r
1877   return 0;\r
1878 } /* f_seeking */\r
1879 \r
1880 static unsigned char f_opening ( void )\r
1881 {\r
1882   F_FILE        * file;\r
1883   F_FILE        * file2;\r
1884   unsigned char   ret;\r
1885   unsigned short  size, pos;\r
1886 \r
1887   _f_dump( "f_opening" );\r
1888 \r
1889 /*test non existing file open r, r+*/\r
1890   file = f_open( "file.bin", "r" );\r
1891   if ( file )\r
1892   {\r
1893     return _f_result( __LINE__, 0 );\r
1894   }\r
1895 \r
1896   file = f_open( "file.bin", "r+" );\r
1897   if ( file )\r
1898   {\r
1899     return _f_result( __LINE__, 0 );\r
1900   }\r
1901 \r
1902 /*test non existing appends     "a" a+*/\r
1903   file = f_open( "file.bin", "a" );\r
1904   if ( !file )\r
1905   {\r
1906     return _f_result( __LINE__, 0 );\r
1907   }\r
1908 \r
1909   file2 = f_open( "file.bin", "a+" ); /*open again*/\r
1910   if ( file2 )\r
1911   {\r
1912     return _f_result( __LINE__, 0 );\r
1913   }\r
1914 \r
1915   ret = f_close( file );\r
1916   if ( ret )\r
1917   {\r
1918     return _f_result( __LINE__, 1 );\r
1919   }\r
1920 \r
1921   ret = f_close( file2 );\r
1922   if ( ret != F_ERR_NOTOPEN )\r
1923   {\r
1924     return _f_result( __LINE__, 2 );\r
1925   }\r
1926 \r
1927 \r
1928 /*try to creates it w*/\r
1929   file = f_open( "file.bin", "w" );\r
1930   if ( !file )\r
1931   {\r
1932     return _f_result( __LINE__, 0 );\r
1933   }\r
1934 \r
1935 /*write 512 times 1*/\r
1936   psp_memset( testbuffer, 1, 512 );                           /*set all 1*/\r
1937   size = (unsigned short)f_write( testbuffer, 1, 512, file ); /*test write*/\r
1938   if ( size != 512 )\r
1939   {\r
1940     return _f_result( __LINE__, size );\r
1941   }\r
1942 \r
1943 /*go back, and read it*/\r
1944   ret = f_rewind( file ); /*back to the begining*/\r
1945   if ( ret )\r
1946   {\r
1947     return _f_result( __LINE__, ret );       /*it should fail*/\r
1948   }\r
1949 \r
1950   size = (unsigned short)f_read( testbuffer, 1, 512, file ); /*test read*/\r
1951   if ( size )\r
1952   {\r
1953     return _f_result( __LINE__, size );        /*it should fail*/\r
1954   }\r
1955 \r
1956 /*close and check size*/\r
1957   size = (unsigned short)f_filelength( "file.bin" );\r
1958   if ( size )\r
1959   {\r
1960     return _f_result( __LINE__, size );        /*has to be zero*/\r
1961   }\r
1962 \r
1963   ret = f_close( file );\r
1964   if ( ret )\r
1965   {\r
1966     return _f_result( __LINE__, ret );\r
1967   }\r
1968 \r
1969   size = (unsigned short)f_filelength( "file.bin" );\r
1970   if ( size != 512 )\r
1971   {\r
1972     return _f_result( __LINE__, size );\r
1973   }\r
1974 \r
1975 /*try to owerwrites it it*/\r
1976   file = f_open( "file.bin", "w+" );\r
1977   if ( !file )\r
1978   {\r
1979     return _f_result( __LINE__, 0 );\r
1980   }\r
1981 \r
1982 /*close and check size*/\r
1983   size = (unsigned short)f_filelength( "file.bin" );\r
1984   if ( size )\r
1985   {\r
1986     return _f_result( __LINE__, size );        /*has to be zero*/\r
1987   }\r
1988 \r
1989   ret = f_close( file );\r
1990   if ( ret )\r
1991   {\r
1992     return _f_result( __LINE__, ret );\r
1993   }\r
1994 \r
1995   size = (unsigned short)f_filelength( "file.bin" );\r
1996   if ( size )\r
1997   {\r
1998     return _f_result( __LINE__, size );\r
1999   }\r
2000 \r
2001 \r
2002 \r
2003 /*test non existing appends     "a" */\r
2004   file = f_open( "file.bin", "r+" );\r
2005   if ( !file )\r
2006   {\r
2007     return _f_result( __LINE__, 0 );\r
2008   }\r
2009 \r
2010 /*write 512 times 1*/\r
2011   psp_memset( testbuffer, 1, 512 );                           /*set all 1*/\r
2012   size = (unsigned short)f_write( testbuffer, 1, 512, file ); /*test write*/\r
2013   if ( size != 512 )\r
2014   {\r
2015     return _f_result( __LINE__, size );\r
2016   }\r
2017 \r
2018 /*go back, and read it*/\r
2019   ret = f_rewind( file );                                    /*back to the begining*/\r
2020   size = (unsigned short)f_read( testbuffer, 1, 512, file ); /*test read*/\r
2021   if ( size != 512 )\r
2022   {\r
2023     return _f_result( __LINE__, size );             /*it should fail*/\r
2024   }\r
2025 \r
2026   ret = f_rewind( file ); /*back to the begining*/\r
2027 \r
2028 /*write 256 times 2*/\r
2029   psp_memset( testbuffer, 2, 512 );                           /*set all 2*/\r
2030   size = (unsigned short)f_write( testbuffer, 1, 256, file ); /*test write*/\r
2031   if ( size != 256 )\r
2032   {\r
2033     return _f_result( __LINE__, size );\r
2034   }\r
2035 \r
2036   pos = (unsigned short)f_tell( file );\r
2037   if ( pos != 256 )\r
2038   {\r
2039     return _f_result( __LINE__, pos );            /*position has to be 512*/\r
2040   }\r
2041 \r
2042   size = (unsigned short)f_filelength( "file.bin" );\r
2043   if ( size )\r
2044   {\r
2045     return _f_result( __LINE__, size );        /*has to be zero*/\r
2046   }\r
2047 \r
2048 /*close and check size*/\r
2049   ret = f_close( file );\r
2050   if ( ret )\r
2051   {\r
2052     return _f_result( __LINE__, ret );\r
2053   }\r
2054 \r
2055   size = (unsigned short)f_filelength( "file.bin" );\r
2056   if ( size != 512 )\r
2057   {\r
2058     return _f_result( __LINE__, size );\r
2059   }\r
2060 \r
2061 \r
2062 /*test non existing appends a+*/\r
2063   file = f_open( "file.bin", "a+" );\r
2064   if ( !file )\r
2065   {\r
2066     return _f_result( __LINE__, 0 );\r
2067   }\r
2068 \r
2069   pos = (unsigned short)f_tell( file );\r
2070   if ( pos != 512 )\r
2071   {\r
2072     return _f_result( __LINE__, pos );            /*position has to be 512*/\r
2073   }\r
2074 \r
2075 /*write 512 times 3*/\r
2076   psp_memset( testbuffer, 3, 512 );                           /*set all 3*/\r
2077   size = (unsigned short)f_write( testbuffer, 1, 512, file ); /*test write*/\r
2078   if ( size != 512 )\r
2079   {\r
2080     return _f_result( __LINE__, size );\r
2081   }\r
2082 \r
2083 /*go back, and read it*/\r
2084   ret = f_rewind( file ); /*back to the begining*/\r
2085   if ( ret )\r
2086   {\r
2087     return _f_result( __LINE__, ret );       /*it should fail*/\r
2088   }\r
2089 \r
2090   size = (unsigned short)f_read( testbuffer, 1, 512, file ); /*test read*/\r
2091   if ( size != 512 )\r
2092   {\r
2093     return _f_result( __LINE__, size );             /*it should fail*/\r
2094   }\r
2095 \r
2096   pos = (unsigned short)f_tell( file );\r
2097   if ( pos != 512 )\r
2098   {\r
2099     return _f_result( __LINE__, pos );            /*position has to be 512*/\r
2100   }\r
2101 \r
2102 /*close and check size*/\r
2103   size = (unsigned short)f_filelength( "file.bin" );\r
2104   if ( size != 512 )\r
2105   {\r
2106     return _f_result( __LINE__, size );             /*has to be zero*/\r
2107   }\r
2108 \r
2109   ret = f_close( file );\r
2110   if ( ret )\r
2111   {\r
2112     return _f_result( __LINE__, ret );\r
2113   }\r
2114 \r
2115   size = (unsigned short)f_filelength( "file.bin" );\r
2116   if ( size != 1024 )\r
2117   {\r
2118     return _f_result( __LINE__, size );\r
2119   }\r
2120 \r
2121 /*close again!*/\r
2122   ret = f_close( file );\r
2123   if ( ret != F_ERR_NOTOPEN )\r
2124   {\r
2125     return _f_result( __LINE__, pos );\r
2126   }\r
2127 \r
2128   ret = f_delete( "file.bin" );\r
2129   if ( ret )\r
2130   {\r
2131     return _f_result( __LINE__, ret );\r
2132   }\r
2133 \r
2134   _f_dump( "passed..." );\r
2135   return 0;\r
2136 } /* f_opening */\r
2137 \r
2138 static unsigned char f_appending ( void )\r
2139 {\r
2140   F_FILE        * file;\r
2141   unsigned short  size, tsize, pos;\r
2142   unsigned char   a, b, ret;\r
2143 \r
2144   _f_dump( "f_appending" );\r
2145 \r
2146   _f_deleteall();\r
2147 \r
2148   for ( tsize = 0, a = 0 ; a < 16 ; a++ )\r
2149   {\r
2150     file = f_open( "ap.bin", "a" );\r
2151     if ( !file )\r
2152     {\r
2153       return _f_result( __LINE__, 0 );\r
2154     }\r
2155 \r
2156     psp_memset( testbuffer, a, sizeof( testbuffer ) );\r
2157     size = (unsigned short)f_write( testbuffer, 1, a + 128, file );\r
2158     if ( size != a + 128 )\r
2159     {\r
2160       return _f_result( __LINE__, size );\r
2161     }\r
2162 \r
2163     size = (unsigned short)f_filelength( "ap.bin" );\r
2164     if ( size != tsize )\r
2165     {\r
2166       return _f_result( __LINE__, size );\r
2167     }\r
2168 \r
2169     tsize += a + 128;\r
2170 \r
2171     ret = f_close( file );\r
2172     if ( ret )\r
2173     {\r
2174       return _f_result( __LINE__, ret );\r
2175     }\r
2176 \r
2177     size = (unsigned short)f_filelength( "ap.bin" );\r
2178     if ( size != tsize )\r
2179     {\r
2180       return _f_result( __LINE__, size );\r
2181     }\r
2182   }\r
2183 \r
2184   file = f_open( "ap.bin", "r" );\r
2185   if ( !file )\r
2186   {\r
2187     return _f_result( __LINE__, 0 );\r
2188   }\r
2189 \r
2190   for ( tsize = 0, a = 0 ; a < 16 ; a++ )\r
2191   {\r
2192     if ( checkfilecontent( a + 128, (char)a, file ) )\r
2193     {\r
2194       return _f_result( __LINE__, a );\r
2195     }\r
2196   }\r
2197 \r
2198   ret = f_close( file );\r
2199   if ( ret )\r
2200   {\r
2201     return _f_result( __LINE__, ret );\r
2202   }\r
2203 \r
2204   for ( tsize = 0, a = 0 ; a < 16 ; a++ )\r
2205   {\r
2206     file = f_open( "ap.bin", "r" );\r
2207     if ( !file )\r
2208     {\r
2209       return _f_result( __LINE__, 0 );\r
2210     }\r
2211 \r
2212     ret = f_seek( file, tsize, F_SEEK_SET );\r
2213     if ( ret )\r
2214     {\r
2215       return _f_result( __LINE__, ret );\r
2216     }\r
2217 \r
2218     pos = (unsigned short)f_tell( file );\r
2219     if ( pos != tsize )\r
2220     {\r
2221       return _f_result( __LINE__, pos );\r
2222     }\r
2223 \r
2224     size = (unsigned short)f_read( testbuffer, 1, a + 128, file );\r
2225     if ( size != a + 128 )\r
2226     {\r
2227       return _f_result( __LINE__, size );\r
2228     }\r
2229 \r
2230     for ( b = 0 ; b < a + 128 ; b++ )\r
2231     {\r
2232       if ( testbuffer[b] != (char)a )\r
2233       {\r
2234         return _f_result( __LINE__, a );\r
2235       }\r
2236     }\r
2237 \r
2238     tsize += a + 128;\r
2239 \r
2240     pos = (unsigned short)f_tell( file );\r
2241     if ( pos != tsize )\r
2242     {\r
2243       return _f_result( __LINE__, pos );\r
2244     }\r
2245 \r
2246     ret = f_close( file );\r
2247     if ( ret )\r
2248     {\r
2249       return _f_result( __LINE__, ret );\r
2250     }\r
2251   }\r
2252 \r
2253   ret = f_close( file );\r
2254   if ( ret != F_ERR_NOTOPEN )\r
2255   {\r
2256     return _f_result( __LINE__, ret );\r
2257   }\r
2258 \r
2259   ret = f_delete( "ap.bin" );\r
2260   if ( ret )\r
2261   {\r
2262     return _f_result( __LINE__, ret );\r
2263   }\r
2264 \r
2265   _f_dump( "passed..." );\r
2266   return 0;\r
2267 } /* f_appending */\r
2268 \r
2269 static unsigned char f_writing ( void )\r
2270 {\r
2271   F_FILE        * file;\r
2272   unsigned short  size;\r
2273   unsigned char   a, ret;\r
2274   F_SPACE         before, after;\r
2275 \r
2276   _f_dump( "f_writing" );\r
2277 \r
2278   ret = f_getfreespace( &before );\r
2279   if ( ret )\r
2280   {\r
2281     return _f_result( __LINE__, ret );\r
2282   }\r
2283 \r
2284   for ( a = 0 ; a < 4 ; a++ )\r
2285   {\r
2286     file = f_open( "wr.bin", "w" );\r
2287     if ( !file )\r
2288     {\r
2289       return _f_result( __LINE__, 0 );\r
2290     }\r
2291 \r
2292     psp_memset( testbuffer, a, sizeof( testbuffer ) );\r
2293     size = (unsigned short)f_write( testbuffer, 1, a * 128, file );\r
2294     if ( size != a * 128 )\r
2295     {\r
2296       return _f_result( __LINE__, size );\r
2297     }\r
2298 \r
2299     ret = f_close( file );\r
2300     if ( ret )\r
2301     {\r
2302       return _f_result( __LINE__, ret );\r
2303     }\r
2304 \r
2305     size = (unsigned short)f_filelength( "wr.bin" );\r
2306     if ( size != a * 128 )\r
2307     {\r
2308       return _f_result( __LINE__, size );\r
2309     }\r
2310 \r
2311     file = f_open( "wr.bin", "r" );\r
2312     if ( !file )\r
2313     {\r
2314       return _f_result( __LINE__, 0 );\r
2315     }\r
2316 \r
2317     if ( checkfilecontent( a * 128, (char)a, file ) )\r
2318     {\r
2319       return _f_result( __LINE__, a );\r
2320     }\r
2321 \r
2322     ret = f_close( file );\r
2323     if ( ret )\r
2324     {\r
2325       return _f_result( __LINE__, ret );\r
2326     }\r
2327   }\r
2328 \r
2329 \r
2330   for ( a = 0 ; a < 4 ; a++ )\r
2331   {\r
2332     file = f_open( "wr.bin", "w+" );\r
2333     if ( !file )\r
2334     {\r
2335       return _f_result( __LINE__, 0 );\r
2336     }\r
2337 \r
2338     psp_memset( testbuffer, a, sizeof( testbuffer ) );\r
2339     size = (unsigned short)f_write( testbuffer, 1, a * 128, file );\r
2340     if ( size != a * 128 )\r
2341     {\r
2342       return _f_result( __LINE__, size );\r
2343     }\r
2344 \r
2345     ret = f_close( file );\r
2346     if ( ret )\r
2347     {\r
2348       return _f_result( __LINE__, ret );\r
2349     }\r
2350 \r
2351     size = (unsigned short)f_filelength( "wr.bin" );\r
2352     if ( size != a * 128 )\r
2353     {\r
2354       return _f_result( __LINE__, size );\r
2355     }\r
2356 \r
2357     file = f_open( "wr.bin", "r+" );\r
2358     if ( !file )\r
2359     {\r
2360       return _f_result( __LINE__, 0 );\r
2361     }\r
2362 \r
2363     if ( checkfilecontent( a * 128, (char)a, file ) )\r
2364     {\r
2365       return _f_result( __LINE__, a );\r
2366     }\r
2367 \r
2368     ret = f_close( file );\r
2369     if ( ret )\r
2370     {\r
2371       return _f_result( __LINE__, ret );\r
2372     }\r
2373   }\r
2374 \r
2375   ret = f_getfreespace( &after );\r
2376   if ( ret )\r
2377   {\r
2378     return _f_result( __LINE__, ret );\r
2379   }\r
2380 \r
2381   if ( before.bad != after.bad )\r
2382   {\r
2383     return _f_result( __LINE__, 0 );\r
2384   }\r
2385 \r
2386   if ( before.free == after.free )\r
2387   {\r
2388     return _f_result( __LINE__, 0 );\r
2389   }\r
2390 \r
2391   if ( before.used == after.used )\r
2392   {\r
2393     return _f_result( __LINE__, 0 );\r
2394   }\r
2395 \r
2396   if ( before.total != after.total )\r
2397   {\r
2398     return _f_result( __LINE__, 0 );\r
2399   }\r
2400 \r
2401   if ( before.used + before.free != after.used + after.free )\r
2402   {\r
2403     return _f_result( __LINE__, 0 );\r
2404   }\r
2405 \r
2406   ret = f_delete( "wr.bin" );\r
2407   if ( ret )\r
2408   {\r
2409     return _f_result( __LINE__, ret );\r
2410   }\r
2411 \r
2412   ret = f_getfreespace( &after );\r
2413   if ( ret )\r
2414   {\r
2415     return _f_result( __LINE__, ret );\r
2416   }\r
2417 \r
2418   if ( before.bad != after.bad )\r
2419   {\r
2420     return _f_result( __LINE__, 0 );\r
2421   }\r
2422 \r
2423   if ( before.free != after.free )\r
2424   {\r
2425     return _f_result( __LINE__, 0 );\r
2426   }\r
2427 \r
2428   if ( before.used != after.used )\r
2429   {\r
2430     return _f_result( __LINE__, 0 );\r
2431   }\r
2432 \r
2433   if ( before.total != after.total )\r
2434   {\r
2435     return _f_result( __LINE__, 0 );\r
2436   }\r
2437 \r
2438   _f_dump( "passed..." );\r
2439   return 0;\r
2440 } /* f_writing */\r
2441 \r
2442 static unsigned char f_dots ( void )\r
2443 {\r
2444   unsigned char  ret;\r
2445   unsigned char  a, size;\r
2446   F_FILE       * file;\r
2447 \r
2448   _f_dump( "f_dots" );\r
2449 \r
2450   ret = f_mkdir( "/tt" );\r
2451   if ( ret )\r
2452   {\r
2453     return _f_result( __LINE__, ret );\r
2454   }\r
2455 \r
2456   ret = f_chdir( "/tt" );\r
2457   if ( ret )\r
2458   {\r
2459     return _f_result( __LINE__, ret );\r
2460   }\r
2461 \r
2462   ret = f_rmdir( "." );\r
2463   if ( ret != F_ERR_NOTFOUND )\r
2464   {\r
2465     return _f_result( __LINE__, ret );\r
2466   }\r
2467 \r
2468   ret = f_rmdir( ".." );\r
2469   if ( ret != F_ERR_NOTFOUND )\r
2470   {\r
2471     return _f_result( __LINE__, ret );\r
2472   }\r
2473 \r
2474   ret = f_chdir( "." );\r
2475   if ( ret )\r
2476   {\r
2477     return _f_result( __LINE__, ret );\r
2478   }\r
2479 \r
2480   ret = _f_checkcwd( f_nameconv( "/tt" ) );\r
2481   if ( ret )\r
2482   {\r
2483     return _f_result( __LINE__, ret );\r
2484   }\r
2485 \r
2486   ret = f_delete( "." );\r
2487   if ( ret != F_ERR_NOTFOUND )\r
2488   {\r
2489     return _f_result( __LINE__, ret );\r
2490   }\r
2491 \r
2492   ret = f_delete( ".." );\r
2493   if ( ret != F_ERR_NOTFOUND )\r
2494   {\r
2495     return _f_result( __LINE__, ret );\r
2496   }\r
2497 \r
2498   ret = f_mkdir( "." );\r
2499   if ( ret != F_ERR_NOTFOUND )\r
2500   {\r
2501     return _f_result( __LINE__, ret );\r
2502   }\r
2503 \r
2504   ret = f_mkdir( ".." );\r
2505   if ( ret != F_ERR_NOTFOUND )\r
2506   {\r
2507     return _f_result( __LINE__, ret );\r
2508   }\r
2509 \r
2510   ret = f_mkdir( "..." );\r
2511   if ( ret != F_ERR_NOTFOUND )\r
2512   {\r
2513     return _f_result( __LINE__, ret );\r
2514   }\r
2515 \r
2516   for ( a = 0 ; a < 6 ; a++ )\r
2517   {\r
2518     char * mode;\r
2519     switch ( a )\r
2520     {\r
2521       case 0:\r
2522         mode = "r";\r
2523         break;\r
2524 \r
2525       case 1:\r
2526         mode = "r+";\r
2527         break;\r
2528 \r
2529       case 2:\r
2530         mode = "w";\r
2531         break;\r
2532 \r
2533       case 3:\r
2534         mode = "w+";\r
2535         break;\r
2536 \r
2537       case 4:\r
2538         mode = "a";\r
2539         break;\r
2540 \r
2541       case 5:\r
2542         mode = "a+";\r
2543         break;\r
2544 \r
2545       default:\r
2546         return _f_result( __LINE__, a );\r
2547     } /* switch */\r
2548 \r
2549     file = f_open( ".", mode );\r
2550     if ( file )\r
2551     {\r
2552       return _f_result( __LINE__, a );\r
2553     }\r
2554 \r
2555     file = f_open( "..", mode );\r
2556     if ( file )\r
2557     {\r
2558       return _f_result( __LINE__, a );\r
2559     }\r
2560 \r
2561     file = f_open( "...", mode );\r
2562     if ( file )\r
2563     {\r
2564       return _f_result( __LINE__, a );\r
2565     }\r
2566   }\r
2567 \r
2568   size = (unsigned char)f_filelength( "." );\r
2569   if ( size )\r
2570   {\r
2571     return _f_result( __LINE__, size );\r
2572   }\r
2573 \r
2574   size = (unsigned char)f_filelength( ".." );\r
2575   if ( size )\r
2576   {\r
2577     return _f_result( __LINE__, size );\r
2578   }\r
2579 \r
2580   size = (unsigned char)f_filelength( "..." );\r
2581   if ( size )\r
2582   {\r
2583     return _f_result( __LINE__, size );\r
2584   }\r
2585 \r
2586 \r
2587   ret = f_chdir( "..." );\r
2588   if ( ret != F_ERR_NOTFOUND )\r
2589   {\r
2590     return _f_result( __LINE__, ret );\r
2591   }\r
2592 \r
2593   ret = f_chdir( ".." );\r
2594   if ( ret )\r
2595   {\r
2596     return _f_result( __LINE__, ret );\r
2597   }\r
2598 \r
2599   ret = f_rmdir( "tt" );\r
2600   if ( ret )\r
2601   {\r
2602     return _f_result( __LINE__, ret );\r
2603   }\r
2604 \r
2605 \r
2606   _f_dump( "passed..." );\r
2607   return 0;\r
2608 } /* f_dots */\r
2609 \r
2610 \r
2611 typedef struct\r
2612 {\r
2613   unsigned char  MagicNum;\r
2614   unsigned char  Line;\r
2615   unsigned char  Buf[87];\r
2616 } struct_TestFileSysEntry;\r
2617 #define NUM_OF_RECORDS 10\r
2618 static unsigned char f_rit ( void )\r
2619 {\r
2620   unsigned char             i;\r
2621   unsigned char             ret;\r
2622   F_FILE                  * File;\r
2623   struct_TestFileSysEntry * Entry = (struct_TestFileSysEntry *)( ( ( (long)testbuffer + 3 ) >> 2 ) << 2 );\r
2624   unsigned short            Pos;\r
2625   unsigned char             Ch;\r
2626   unsigned char             Founded;\r
2627 \r
2628   _f_dump( "f_rit" );\r
2629 \r
2630   (void)f_delete( "MyTest" );\r
2631   File = f_open( "MyTest", "a+" );\r
2632   if ( !File )\r
2633   {\r
2634     return _f_result( __LINE__, 0 );\r
2635   }\r
2636 \r
2637   /* add records  */\r
2638   for ( i = 0 ; i < NUM_OF_RECORDS ; i++ )\r
2639   {\r
2640     Ch = (char)( i % 10 );\r
2641     Entry->MagicNum = 0xbc;\r
2642     Entry->Line = i;\r
2643     Entry->Buf[0] = Ch;\r
2644     Entry->Buf[10] = (unsigned char)( Ch + 1 );\r
2645 \r
2646     if ( F_NO_ERROR != f_seek( File, 0, F_SEEK_END ) )\r
2647     {\r
2648       return _f_result( __LINE__, 0 ); /* Fail, could not go to the end of the file */\r
2649     }\r
2650 \r
2651     if ( sizeof( struct_TestFileSysEntry ) != f_write( (void *)Entry, 1, sizeof( struct_TestFileSysEntry ), File ) )\r
2652     {\r
2653       return _f_result( __LINE__, 0 ); /* Fail, could not write new entry */\r
2654     }\r
2655 \r
2656     Pos = (unsigned short)f_tell( File );\r
2657     if ( ( ( Pos / sizeof( struct_TestFileSysEntry ) ) - 1 ) != i )\r
2658     {\r
2659       return _f_result( __LINE__, 0 ); /* Fail, wrong file position */\r
2660     }\r
2661 \r
2662     if ( F_NO_ERROR != f_seek( File, (long)( Pos - sizeof( struct_TestFileSysEntry ) ), F_SEEK_SET ) )\r
2663     {\r
2664       return _f_result( __LINE__, 0 ); /* Fail, could not go to new entry position */\r
2665     }\r
2666 \r
2667     if ( sizeof( struct_TestFileSysEntry ) != f_read( (void *)Entry, 1, sizeof( struct_TestFileSysEntry ), File ) )\r
2668     {\r
2669       return _f_result( __LINE__, 0 ); /* Fail, could not read the new entry */\r
2670     }\r
2671 \r
2672     if ( ( Entry->MagicNum != 0xbc ) || ( Entry->Line != (int)i ) || ( Entry->Buf[0] != Ch ) || ( Entry->Buf[10] != Ch + 1 ) )\r
2673     {\r
2674       return _f_result( __LINE__, 0 ); /*Fail, the new entry is corrupted"*/\r
2675     }\r
2676   }\r
2677 \r
2678   ret = f_close( File );\r
2679   if ( ret )\r
2680   {\r
2681     return _f_result( __LINE__, ret );\r
2682   }\r
2683 \r
2684 \r
2685   /*Open file again*/\r
2686   File = f_open( "MyTest", "a+" );\r
2687   if ( !File )\r
2688   {\r
2689     return _f_result( __LINE__, 0 );\r
2690   }\r
2691 \r
2692   /* read records  */\r
2693   for ( i = 0 ; i < NUM_OF_RECORDS ; i++ )\r
2694   {\r
2695     Ch = (char)( i % 10 );\r
2696 \r
2697     if ( F_NO_ERROR != f_seek( File, 0, F_SEEK_SET ) )\r
2698     {\r
2699       return _f_result( __LINE__, 0 ); /* Fail, could not go to the start of the file */\r
2700     }\r
2701 \r
2702     Founded = 0;\r
2703     while ( sizeof( struct_TestFileSysEntry ) == f_read( (void *)Entry, 1, sizeof( struct_TestFileSysEntry ), File ) )\r
2704     {\r
2705       if ( ( Entry->MagicNum == 0xbc )\r
2706           && ( Entry->Line == (int)i )\r
2707           && ( Entry->Buf[0] == Ch )\r
2708           && ( Entry->Buf[10] == Ch + 1 ) )\r
2709       {\r
2710         Founded = 1;\r
2711         break;\r
2712       }\r
2713     }\r
2714 \r
2715     if ( !Founded )\r
2716     {\r
2717       return _f_result( __LINE__, i );      /* Entry not founded */\r
2718     }\r
2719   }\r
2720 \r
2721   ret = f_close( File );\r
2722   if ( ret )\r
2723   {\r
2724     return _f_result( __LINE__, ret );\r
2725   }\r
2726 \r
2727 \r
2728   ret = f_delete( "MyTest" );\r
2729   if ( ret )\r
2730   {\r
2731     return _f_result( __LINE__, ret );\r
2732   }\r
2733 \r
2734   _f_dump( "passed..." );\r
2735 \r
2736   return 0;\r
2737 } /* f_rit */\r
2738 \r
2739 \r
2740 \r
2741 \r
2742 static unsigned char f_truncating ( void )\r
2743 {\r
2744   F_FILE       * file;\r
2745   unsigned long  size;\r
2746   unsigned char  ret;\r
2747 \r
2748   _f_dump( "f_truncating" );\r
2749 \r
2750   file = f_open( "test.bin", "w+" );\r
2751   if ( !file )\r
2752   {\r
2753     return _f_result( __LINE__, 0 );\r
2754   }\r
2755 \r
2756   (void)psp_memset( testbuffer, 1, F_MAX_SEEK_TEST );\r
2757   size = (unsigned long)f_write( testbuffer, 1, F_MAX_SEEK_TEST, file );\r
2758   if ( size != F_MAX_SEEK_TEST )\r
2759   {\r
2760     return _f_result( __LINE__, size );\r
2761   }\r
2762 \r
2763   ret = f_close( file );\r
2764   if ( ret )\r
2765   {\r
2766     return _f_result( __LINE__, ret );\r
2767   }\r
2768 \r
2769   file = f_truncate( "test.bin", F_MAX_SEEK_TEST - 4 );\r
2770   if ( !file )\r
2771   {\r
2772     return _f_result( __LINE__, 0 );\r
2773   }\r
2774 \r
2775   ret = f_close( file );\r
2776   if ( ret )\r
2777   {\r
2778     return _f_result( __LINE__, ret );\r
2779   }\r
2780 \r
2781   size = (unsigned long)f_filelength( "test.bin" );\r
2782   if ( size != F_MAX_SEEK_TEST - 4 )\r
2783   {\r
2784     return _f_result( __LINE__, size );\r
2785   }\r
2786 \r
2787 \r
2788   file = f_truncate( "test.bin", F_MAX_SEEK_TEST );\r
2789   if ( !file )\r
2790   {\r
2791     return _f_result( __LINE__, 0 );\r
2792   }\r
2793 \r
2794   ret = f_close( file );\r
2795   if ( ret )\r
2796   {\r
2797     return _f_result( __LINE__, ret );\r
2798   }\r
2799 \r
2800   size = (unsigned long)f_filelength( "test.bin" );\r
2801   if ( size != F_MAX_SEEK_TEST )\r
2802   {\r
2803     return _f_result( __LINE__, size );\r
2804   }\r
2805 \r
2806 \r
2807   file = f_truncate( "test.bin", ( F_MAX_SEEK_TEST / 2 ) - 92 );\r
2808   if ( !file )\r
2809   {\r
2810     return _f_result( __LINE__, 0 );\r
2811   }\r
2812 \r
2813   (void)psp_memset( testbuffer, 2, 92 );\r
2814   size = (unsigned long)f_write( testbuffer, 1, 92, file );\r
2815   if ( size != 92 )\r
2816   {\r
2817     return _f_result( __LINE__, size );\r
2818   }\r
2819 \r
2820   ret = f_close( file );\r
2821   if ( ret )\r
2822   {\r
2823     return _f_result( __LINE__, ret );\r
2824   }\r
2825 \r
2826   size = (unsigned long)f_filelength( "test.bin" );\r
2827   if ( size != ( F_MAX_SEEK_TEST / 2 ) )\r
2828   {\r
2829     return _f_result( __LINE__, size );\r
2830   }\r
2831 \r
2832 \r
2833   file = f_truncate( "test.bin", 1 );\r
2834   if ( !file )\r
2835   {\r
2836     return _f_result( __LINE__, 0 );\r
2837   }\r
2838 \r
2839   (void)psp_memset( testbuffer, 3, 2 );\r
2840   size = (unsigned long)f_write( testbuffer, 1, 2, file );\r
2841   if ( size != 2 )\r
2842   {\r
2843     return _f_result( __LINE__, size );\r
2844   }\r
2845 \r
2846   ret = f_close( file );\r
2847   if ( ret )\r
2848   {\r
2849     return _f_result( __LINE__, ret );\r
2850   }\r
2851 \r
2852   size = (unsigned long)f_filelength( "test.bin" );\r
2853   if ( size != 3 )\r
2854   {\r
2855     return _f_result( __LINE__, size );\r
2856   }\r
2857 \r
2858 \r
2859 \r
2860   _f_dump( "passed..." );\r
2861   return 0;\r
2862 } /* f_truncating */\r
2863 \r
2864 \r
2865 void f_dotest ( unsigned char t )\r
2866 {\r
2867   _f_dump( "File system test started..." );\r
2868   _f_dump( "WARNING: The contents of your drive will be destroyed!\n" );\r
2869 \r
2870   (void)_f_poweron();\r
2871 \r
2872   switch ( t )\r
2873   {\r
2874     case 0:\r
2875     case 1:\r
2876       (void)f_formatting();\r
2877       if ( t )\r
2878       {\r
2879         break;\r
2880       }\r
2881 \r
2882 \r
2883     /* fall through */\r
2884     case 2:\r
2885       (void)f_dirtest();\r
2886       if ( t )\r
2887       {\r
2888         break;\r
2889       }\r
2890 \r
2891 \r
2892     /* fall through */\r
2893     case 3:\r
2894       (void)f_findingtest();\r
2895       if ( t )\r
2896       {\r
2897         break;\r
2898       }\r
2899 \r
2900 \r
2901     /* fall through */\r
2902     case 4:\r
2903       (void)f_powerfail();\r
2904       if ( t )\r
2905       {\r
2906         break;\r
2907       }\r
2908 \r
2909 \r
2910     /* fall through */\r
2911     case 5:\r
2912       (void)f_seeking( 128 );\r
2913       if ( t )\r
2914       {\r
2915         break;\r
2916       }\r
2917 \r
2918 #if ( F_MAX_SEEK_TEST > 128 )\r
2919 \r
2920     /* fall through */\r
2921     case 6:\r
2922       (void)f_seeking( 256 );\r
2923       if ( t )\r
2924       {\r
2925         break;\r
2926       }\r
2927 \r
2928 #endif\r
2929 #if ( F_MAX_SEEK_TEST > 256 )\r
2930 \r
2931     /* fall through */\r
2932     case 7:\r
2933       (void)f_seeking( 512 );\r
2934       if ( t )\r
2935       {\r
2936         break;\r
2937       }\r
2938 \r
2939 #endif\r
2940 #if ( F_MAX_SEEK_TEST > 512 )\r
2941 \r
2942     /* fall through */\r
2943     case 8:\r
2944       (void)f_seeking( 1024 );\r
2945       if ( t )\r
2946       {\r
2947         break;\r
2948       }\r
2949 \r
2950 #endif\r
2951 #if ( F_MAX_SEEK_TEST > 1024 )\r
2952 \r
2953     /* fall through */\r
2954     case 9:\r
2955       (void)f_seeking( 2048 );\r
2956       if ( t )\r
2957       {\r
2958         break;\r
2959       }\r
2960 \r
2961 #endif\r
2962 #if ( F_MAX_SEEK_TEST > 2048 )\r
2963 \r
2964     /* fall through */\r
2965     case 10:\r
2966       (void)f_seeking( 4096 );\r
2967       if ( t )\r
2968       {\r
2969         break;\r
2970       }\r
2971 \r
2972 #endif\r
2973 #if ( F_MAX_SEEK_TEST > 4096 )\r
2974 \r
2975     /* fall through */\r
2976     case 11:\r
2977       (void)f_seeking( 8192 );\r
2978       if ( t )\r
2979       {\r
2980         break;\r
2981       }\r
2982 \r
2983 #endif\r
2984 #if ( F_MAX_SEEK_TEST > 8192 )\r
2985 \r
2986     /* fall through */\r
2987     case 12:\r
2988       (void)f_seeking( 16384 );\r
2989       if ( t )\r
2990       {\r
2991         break;\r
2992       }\r
2993 \r
2994 #endif\r
2995 #if ( F_MAX_SEEK_TEST > 16384 )\r
2996 \r
2997     /* fall through */\r
2998     case 13:\r
2999       (void)f_seeking( 32768 );\r
3000       if ( t )\r
3001       {\r
3002         break;\r
3003       }\r
3004 \r
3005 #endif\r
3006 \r
3007     /* fall through */\r
3008     case 14:\r
3009       (void)f_opening();\r
3010       if ( t )\r
3011       {\r
3012         break;\r
3013       }\r
3014 \r
3015 \r
3016     /* fall through */\r
3017     case 15:\r
3018       (void)f_appending();\r
3019       if ( t )\r
3020       {\r
3021         break;\r
3022       }\r
3023 \r
3024 \r
3025     /* fall through */\r
3026     case 16:\r
3027       (void)f_writing();\r
3028       if ( t )\r
3029       {\r
3030         break;\r
3031       }\r
3032 \r
3033 \r
3034     /* fall through */\r
3035     case 17:\r
3036       (void)f_dots();\r
3037       if ( t )\r
3038       {\r
3039         break;\r
3040       }\r
3041 \r
3042 \r
3043     /* fall through */\r
3044     case 18:\r
3045       (void)f_rit();\r
3046       if ( t )\r
3047       {\r
3048         break;\r
3049       }\r
3050 \r
3051     case 19:\r
3052       (void)f_truncating();\r
3053       if ( t )\r
3054       {\r
3055         break;\r
3056       }\r
3057 \r
3058       break;\r
3059   } /* switch */\r
3060 \r
3061   _f_dump( "End of tests..." );\r
3062 } /* f_dotest */\r
3063 \r
3064 \r
3065 /****************************************************************************\r
3066  *\r
3067  * end of test.c\r
3068  *\r
3069  ***************************************************************************/\r