17 #include "InputFileTest.h"
20 #include "StringBasics.h"
22 void testAdditional(
const char *extension);
26 int main(
int argc,
char ** argv)
34 std::cout <<
"\nAdditional Tests: " << std::endl;
36 testAdditional(
"txt");
37 #ifdef __ZLIB_AVAILABLE__
43 const int IFILE_Test::TEST_FILE_SIZE = 37;
44 const int IFILE_Test::BGZF_TEST_FILE_SIZE = 93;
45 const std::string IFILE_Test::TEST_FILE_CONTENTS =
"ABCDabcd1234\nEFGefg567\nhijklHIJKL8910";
47 void IFILE_Test::test()
49 std::cout <<
"\nUncompressedFileType Tests:" << std::endl;
52 #ifdef __ZLIB_AVAILABLE__
53 std::cout <<
"\nGzipFileType Tests:" << std::endl;
56 std::cout <<
"\nBgzfFileType Tests:" << std::endl;
59 std::cout <<
"\n.glf file Tests:" << std::endl;
65 void IFILE_Test::testAll(
const char* extension)
67 test_readFromFile(extension);
68 test_readTilChar(extension);
69 test_ifeof_ifrewind(extension);
70 test_ifread_ifgetc(extension);
71 test_ifclose(extension);
72 test_ifseek(extension);
73 test_noExistRead(extension);
77 void IFILE_Test::test_readFromFile(
const char* extension)
83 assert(myFileTypePtr != NULL);
85 assert(myFileTypePtr->isOpen());
92 int totalBytesPreviouslyRead = 0;
95 numBytesRead = readFromFile(myTestBuffer, 4);
96 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[0]);
97 assert(myTestBuffer[1] == TEST_FILE_CONTENTS[1]);
98 assert(myTestBuffer[2] == TEST_FILE_CONTENTS[2]);
99 assert(myTestBuffer[3] == TEST_FILE_CONTENTS[3]);
100 assert(numBytesRead == 4);
101 totalBytesPreviouslyRead += numBytesRead;
103 assert(myCurrentBufferSize == 0);
104 assert(myBufferIndex == 0);
106 assert(myFileTypePtr->eof() ==
false);
107 assert(
ifeof() ==
false);
110 numBytesRead = readFromFile(myTestBuffer, 2);
112 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[4]);
113 assert(myTestBuffer[1] == TEST_FILE_CONTENTS[5]);
114 assert(myTestBuffer[2] == TEST_FILE_CONTENTS[2]);
115 assert(myTestBuffer[3] == TEST_FILE_CONTENTS[3]);
116 assert(numBytesRead == 2);
117 totalBytesPreviouslyRead += numBytesRead;
119 assert(myCurrentBufferSize == 0);
120 assert(myBufferIndex == 0);
122 assert(myFileTypePtr->eof() ==
false);
123 assert(
ifeof() ==
false);
128 numBytesRead = readFromFile(myTestBuffer, MAX_TEST_BUFFER_SIZE);
131 assert(numBytesRead == (TEST_FILE_SIZE - totalBytesPreviouslyRead));
132 assert(numBytesRead != MAX_TEST_BUFFER_SIZE);
133 for(
int i = 0; i < numBytesRead; i++)
135 assert(myTestBuffer[i] ==
136 TEST_FILE_CONTENTS[totalBytesPreviouslyRead+i]);
138 totalBytesPreviouslyRead += numBytesRead;
139 assert(myFileTypePtr->eof() != 0);
140 assert(
ifeof() != 0);
143 numBytesRead = readFromFile(myTestBuffer, MAX_TEST_BUFFER_SIZE);
144 assert(numBytesRead == 0);
146 assert(myFileTypePtr->eof() != 0);
147 assert(
ifeof() != 0);
151 std::cout <<
" Passed test_readFromFile" << std::endl;
157 void IFILE_Test::test_readTilChar(
const char* extension)
163 assert(myFileTypePtr != NULL);
165 assert(myFileTypePtr->isOpen());
171 std::string output =
"";
172 std::string endChars =
"a5d";
175 assert(output ==
"ABCD");
179 assert(output ==
"bc");
182 assert(output ==
"bc1234\nEFGefg");
186 assert(output ==
"67\nhijklHIJKL8910");
201 std::cout <<
" Passed test_readTilChar" << std::endl;
205 void IFILE_Test::test_ifeof_ifrewind(
const char* extension)
211 assert(myFileTypePtr != NULL);
213 assert(myFileTypePtr->isOpen());
216 assert(
ifeof() ==
false);
220 int totalBytesPreviouslyRead = 0;
221 int numBytesRead = 0;
231 numBytesRead = readFromFile(myTestBuffer, 1);
232 assert(numBytesRead == 1);
233 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
236 totalBytesPreviouslyRead += numBytesRead;
238 assert(
ifeof() ==
false);
242 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
245 ++totalBytesPreviouslyRead;
247 assert(
ifeof() ==
false);
248 assert(
iftell() == totalBytesPreviouslyRead);
251 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
252 assert(numBytesRead == (TEST_FILE_SIZE - totalBytesPreviouslyRead));
254 assert(numBytesRead != MAX_TEST_BUFFER_SIZE);
257 totalBytesPreviouslyRead += numBytesRead;
259 assert(myFileTypePtr->eof() != 0);
260 assert(
ifeof() != 0);
262 numBytesRead = readFromFile(myTestBuffer, 1);
263 assert(numBytesRead == 0);
265 assert(
ifeof() != 0);
269 if((strcmp(extension,
"bam") == 0) || (strcmp(extension,
"glf") == 0))
271 assert(
iftell() == (BGZF_TEST_FILE_SIZE << 16));
275 assert(
iftell() == TEST_FILE_SIZE);
282 totalBytesPreviouslyRead = 0;
284 assert(
ifeof() ==
false);
292 numBytesRead = readFromFile(myTestBuffer, 1);
293 assert(numBytesRead == 1);
294 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
297 totalBytesPreviouslyRead += numBytesRead;
299 assert(
ifeof() ==
false);
303 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
306 ++totalBytesPreviouslyRead;
308 assert(
ifeof() ==
false);
312 if((strcmp(extension,
"bam") == 0) || (strcmp(extension,
"glf") == 0))
317 assert(
iftell() == totalBytesPreviouslyRead);
319 catch (std::exception& e)
322 assert(strcmp(e.what(),
"IFILE: CANNOT use buffered reads and tell for BGZF files") == 0);
328 assert(
iftell() == totalBytesPreviouslyRead);
332 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
333 assert(numBytesRead == (TEST_FILE_SIZE - totalBytesPreviouslyRead));
336 totalBytesPreviouslyRead += numBytesRead;
338 assert(
ifeof() != 0);
341 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
342 assert(numBytesRead == 0);
344 assert(
ifeof() != 0);
348 if((strcmp(extension,
"bam") == 0) || (strcmp(extension,
"glf") == 0))
353 assert(
iftell() == (BGZF_TEST_FILE_SIZE << 16));
355 catch (std::exception& e)
358 assert(strcmp(e.what(),
"IFILE: CANNOT use buffered reads and tell for BGZF files") == 0);
362 assert(
iftell() == (BGZF_TEST_FILE_SIZE << 16));
366 assert(
iftell() == TEST_FILE_SIZE);
372 totalBytesPreviouslyRead = 0;
374 assert(
ifeof() ==
false);
381 totalBytesPreviouslyRead = 0;
383 assert(
ifeof() ==
false);
394 std::cout <<
" Passed test_ifeof_ifrewind" << std::endl;
398 void IFILE_Test::test_ifread_ifgetc(
const char* extension)
404 assert(myFileTypePtr != NULL);
406 assert(myFileTypePtr->isOpen());
408 int numBytesRead = 0;
409 int totalBytesPreviouslyRead = 0;
413 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
414 assert(numBytesRead == TEST_FILE_SIZE);
416 for(
int i = 0; i < TEST_FILE_SIZE; i++)
418 assert(myTestBuffer[i] == TEST_FILE_CONTENTS[i]);
420 totalBytesPreviouslyRead += numBytesRead;
423 assert(myCurrentBufferSize == TEST_FILE_SIZE);
424 assert(myBufferIndex == TEST_FILE_SIZE);
426 assert(myFileTypePtr->eof() != 0);
427 assert(
ifeof() != 0);
430 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
431 assert(numBytesRead == 0);
433 assert(myCurrentBufferSize == 0);
434 assert(myBufferIndex == 0);
435 assert(
ifeof() != 0);
438 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
439 assert(numBytesRead == 0);
441 assert(myCurrentBufferSize == 0);
442 assert(myBufferIndex == 0);
443 assert(
ifeof() != 0);
448 totalBytesPreviouslyRead = 0;
454 for(
int index = 0; index < TEST_FILE_SIZE; index++)
458 assert(readChar == TEST_FILE_CONTENTS[index]);
460 assert(myCurrentBufferSize == TEST_FILE_SIZE);
461 assert(myBufferIndex == index+1);
466 assert(readChar == EOF);
467 assert(myCurrentBufferSize == 0);
468 assert(myBufferIndex == 0);
473 assert(readChar == EOF);
474 assert(myCurrentBufferSize == 0);
475 assert(myBufferIndex == 0);
479 totalBytesPreviouslyRead = 0;
483 numBytesRead =
ifread(myTestBuffer, 4);
484 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[0]);
485 assert(myTestBuffer[1] == TEST_FILE_CONTENTS[1]);
486 assert(myTestBuffer[2] == TEST_FILE_CONTENTS[2]);
487 assert(myTestBuffer[3] == TEST_FILE_CONTENTS[3]);
488 assert(numBytesRead == 4);
489 totalBytesPreviouslyRead += numBytesRead;
491 assert(myCurrentBufferSize == TEST_FILE_SIZE);
492 assert(myBufferIndex == 4);
494 assert(
ifeof() ==
false);
497 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
498 assert(numBytesRead == (TEST_FILE_SIZE - (
int)totalBytesPreviouslyRead));
500 for(
int i = 0; i < numBytesRead; i++)
502 assert(myTestBuffer[i] ==
503 TEST_FILE_CONTENTS[i + totalBytesPreviouslyRead]);
505 totalBytesPreviouslyRead += numBytesRead;
508 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
509 assert(numBytesRead == 0);
511 assert(myCurrentBufferSize == 0);
512 assert(myBufferIndex == 0);
513 assert(
ifeof() != 0);
516 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
517 assert(numBytesRead == 0);
519 assert(myCurrentBufferSize == 0);
520 assert(myBufferIndex == 0);
521 assert(
ifeof() != 0);
525 totalBytesPreviouslyRead = 0;
529 numBytesRead =
ifread(myTestBuffer, 4);
530 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[0]);
531 assert(myTestBuffer[1] == TEST_FILE_CONTENTS[1]);
532 assert(myTestBuffer[2] == TEST_FILE_CONTENTS[2]);
533 assert(myTestBuffer[3] == TEST_FILE_CONTENTS[3]);
534 assert(numBytesRead == 4);
535 totalBytesPreviouslyRead += numBytesRead;
537 assert(myCurrentBufferSize == TEST_FILE_SIZE);
538 assert(myBufferIndex == 4);
540 assert(
ifeof() ==
false);
544 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
545 int bufferSize = TEST_FILE_SIZE;
546 assert(myCurrentBufferSize == bufferSize);
547 assert(myBufferIndex == 5);
548 totalBytesPreviouslyRead++;
551 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
552 assert(myCurrentBufferSize == bufferSize);
553 assert(myBufferIndex == 6);
554 totalBytesPreviouslyRead++;
557 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
558 assert(numBytesRead == (TEST_FILE_SIZE - (
int)totalBytesPreviouslyRead));
560 for(
int i = 0; i < numBytesRead; i++)
562 assert(myTestBuffer[i] ==
563 TEST_FILE_CONTENTS[i + totalBytesPreviouslyRead]);
565 totalBytesPreviouslyRead += numBytesRead;
568 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
569 assert(numBytesRead == 0);
571 assert(myCurrentBufferSize == 0);
572 assert(myBufferIndex == 0);
573 assert(
ifeof() != 0);
576 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
577 assert(numBytesRead == 0);
579 assert(myCurrentBufferSize == 0);
580 assert(myBufferIndex == 0);
581 assert(
ifeof() != 0);
585 totalBytesPreviouslyRead = 0;
586 assert(myCurrentBufferSize == 0);
587 assert(myBufferIndex == 0);
592 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
593 bufferSize = TEST_FILE_SIZE;
594 assert(myCurrentBufferSize == bufferSize);
595 assert(myBufferIndex == 1);
596 totalBytesPreviouslyRead++;
599 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
600 assert(myCurrentBufferSize == bufferSize);
601 assert(myBufferIndex == 2);
602 totalBytesPreviouslyRead++;
605 numBytesRead =
ifread(myTestBuffer, 4);
606 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
607 assert(myTestBuffer[1] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead + 1]);
608 assert(myTestBuffer[2] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead + 2]);
609 assert(myTestBuffer[3] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead + 3]);
610 assert(numBytesRead == 4);
611 totalBytesPreviouslyRead += numBytesRead;
613 assert(myCurrentBufferSize == bufferSize);
614 assert(myBufferIndex == totalBytesPreviouslyRead);
616 assert(
ifeof() ==
false);
620 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
621 assert(myCurrentBufferSize == bufferSize);
622 totalBytesPreviouslyRead++;
623 assert(myBufferIndex == totalBytesPreviouslyRead);
626 assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
627 assert(myCurrentBufferSize == bufferSize);
628 totalBytesPreviouslyRead++;
629 assert(myBufferIndex == totalBytesPreviouslyRead);
632 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
633 assert(numBytesRead == (TEST_FILE_SIZE - (
int)totalBytesPreviouslyRead));
635 for(
int i = 0; i < numBytesRead; i++)
637 assert(myTestBuffer[i] ==
638 TEST_FILE_CONTENTS[i + totalBytesPreviouslyRead]);
640 totalBytesPreviouslyRead += numBytesRead;
641 assert(myBufferIndex == 0);
642 assert(myCurrentBufferSize == 0);
645 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
646 assert(numBytesRead == 0);
648 assert(myCurrentBufferSize == 0);
649 assert(myBufferIndex == 0);
650 assert(
ifeof() != 0);
653 numBytesRead =
ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
654 assert(numBytesRead == 0);
656 assert(myCurrentBufferSize == 0);
657 assert(myBufferIndex == 0);
658 assert(
ifeof() != 0);
662 totalBytesPreviouslyRead = 0;
663 assert(myCurrentBufferSize == 0);
664 assert(myBufferIndex == 0);
675 openLargeFile(extension);
679 int largeTestFileSize = DEFAULT_BUFFER_SIZE + 5;
680 char largeBuffer[largeTestFileSize + 5];
683 assert(myFileTypePtr != NULL);
685 assert(myFileTypePtr->isOpen());
688 totalBytesPreviouslyRead = 0;
694 numBytesRead =
ifread(largeBuffer, 2);
695 assert(numBytesRead == 2);
696 numBytesRead =
ifread(largeBuffer + 2, DEFAULT_BUFFER_SIZE * 3);
697 assert(numBytesRead == DEFAULT_BUFFER_SIZE + 3);
699 assert(myFileTypePtr->eof() != 0);
700 assert(
ifeof() != 0);
701 numBytesRead =
ifread(largeBuffer + DEFAULT_BUFFER_SIZE + 3, 2);
702 assert(numBytesRead == 0);
705 for(
unsigned int i = 0; i < DEFAULT_BUFFER_SIZE; i++)
707 assert(largeBuffer[i] ==
'0');
710 assert(largeBuffer[DEFAULT_BUFFER_SIZE] ==
'1');
711 assert(largeBuffer[DEFAULT_BUFFER_SIZE+1] ==
'2');
712 assert(largeBuffer[DEFAULT_BUFFER_SIZE+2] ==
'3');
713 assert(largeBuffer[DEFAULT_BUFFER_SIZE+3] ==
'4');
714 assert(largeBuffer[DEFAULT_BUFFER_SIZE+4] ==
'5');
716 totalBytesPreviouslyRead += numBytesRead;
721 assert(myCurrentBufferSize == 0);
722 assert(myBufferIndex == 0);
724 assert(myFileTypePtr->eof() != 0);
725 assert(
ifeof() != 0);
728 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
729 assert(numBytesRead == 0);
731 assert(myCurrentBufferSize == 0);
732 assert(myBufferIndex == 0);
733 assert(
ifeof() != 0);
736 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
737 assert(numBytesRead == 0);
739 assert(myCurrentBufferSize == 0);
740 assert(myBufferIndex == 0);
741 assert(
ifeof() != 0);
746 totalBytesPreviouslyRead = 0;
750 numBytesRead =
ifread(largeBuffer, largeTestFileSize + 4);
751 assert(numBytesRead == largeTestFileSize);
754 for(
unsigned int i = 0; i < DEFAULT_BUFFER_SIZE; i++)
756 assert(largeBuffer[i] ==
'0');
759 assert(largeBuffer[DEFAULT_BUFFER_SIZE] ==
'1');
760 assert(largeBuffer[DEFAULT_BUFFER_SIZE+1] ==
'2');
761 assert(largeBuffer[DEFAULT_BUFFER_SIZE+2] ==
'3');
762 assert(largeBuffer[DEFAULT_BUFFER_SIZE+3] ==
'4');
763 assert(largeBuffer[DEFAULT_BUFFER_SIZE+4] ==
'5');
765 totalBytesPreviouslyRead += numBytesRead;
770 assert(myCurrentBufferSize == 0);
771 assert(myBufferIndex == 0);
773 assert(myFileTypePtr->eof() != 0);
774 assert(
ifeof() != 0);
777 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
778 assert(numBytesRead == 0);
780 assert(myCurrentBufferSize == 0);
781 assert(myBufferIndex == 0);
782 assert(
ifeof() != 0);
785 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
786 assert(numBytesRead == 0);
788 assert(myCurrentBufferSize == 0);
789 assert(myBufferIndex == 0);
790 assert(
ifeof() != 0);
795 totalBytesPreviouslyRead = 0;
801 for(
int index = 0; index < (int)DEFAULT_BUFFER_SIZE; index++)
805 assert(readChar ==
'0');
807 assert(myCurrentBufferSize == (
int)DEFAULT_BUFFER_SIZE);
808 assert(myBufferIndex == index+1);
812 assert(readChar ==
'1');
814 assert(myCurrentBufferSize == 5);
815 assert(myBufferIndex == 1);
817 assert(readChar ==
'2');
819 assert(myCurrentBufferSize == 5);
820 assert(myBufferIndex == 2);
822 assert(readChar ==
'3');
824 assert(myCurrentBufferSize == 5);
825 assert(myBufferIndex == 3);
827 assert(readChar ==
'4');
829 assert(myCurrentBufferSize == 5);
830 assert(myBufferIndex == 4);
832 assert(readChar ==
'5');
834 assert(myCurrentBufferSize == 5);
835 assert(myBufferIndex == 5);
839 assert(readChar == EOF);
840 assert(myCurrentBufferSize == 0);
841 assert(myBufferIndex == 0);
846 assert(readChar == EOF);
847 assert(myCurrentBufferSize == 0);
848 assert(myBufferIndex == 0);
852 totalBytesPreviouslyRead = 0;
856 numBytesRead =
ifread(largeBuffer, 4);
857 assert(largeBuffer[0] ==
'0');
858 assert(largeBuffer[1] ==
'0');
859 assert(largeBuffer[2] ==
'0');
860 assert(largeBuffer[3] ==
'0');
861 assert(numBytesRead == 4);
862 totalBytesPreviouslyRead += numBytesRead;
864 assert(myCurrentBufferSize == (
int)DEFAULT_BUFFER_SIZE);
865 assert(myBufferIndex == 4);
867 assert(
ifeof() ==
false);
870 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
871 assert(numBytesRead == (largeTestFileSize - (
int)totalBytesPreviouslyRead));
873 for(
int i = 0; i < (numBytesRead-5); i++)
875 assert(largeBuffer[i] ==
'0');
878 assert(largeBuffer[numBytesRead - 5] ==
'1');
879 assert(largeBuffer[numBytesRead - 5 + 1] ==
'2');
880 assert(largeBuffer[numBytesRead - 5 + 2] ==
'3');
881 assert(largeBuffer[numBytesRead - 5 + 3] ==
'4');
882 assert(largeBuffer[numBytesRead - 5 + 4] ==
'5');
883 totalBytesPreviouslyRead += numBytesRead;
886 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
887 assert(numBytesRead == 0);
889 assert(myCurrentBufferSize == 0);
890 assert(myBufferIndex == 0);
891 assert(
ifeof() != 0);
894 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
895 assert(numBytesRead == 0);
897 assert(myCurrentBufferSize == 0);
898 assert(myBufferIndex == 0);
899 assert(
ifeof() != 0);
903 totalBytesPreviouslyRead = 0;
907 numBytesRead =
ifread(largeBuffer, 2);
908 assert(largeBuffer[0] ==
'0');
909 assert(largeBuffer[1] ==
'0');
910 assert(numBytesRead == 2);
911 totalBytesPreviouslyRead += numBytesRead;
913 assert(myCurrentBufferSize == (
int)DEFAULT_BUFFER_SIZE);
914 assert(myBufferIndex == 2);
916 assert(
ifeof() ==
false);
920 assert(readChar ==
'0');
921 bufferSize = DEFAULT_BUFFER_SIZE;
922 assert(myCurrentBufferSize == bufferSize);
923 assert(myBufferIndex == 3);
924 totalBytesPreviouslyRead++;
927 assert(readChar ==
'0');
928 assert(myCurrentBufferSize == bufferSize);
929 assert(myBufferIndex == 4);
930 totalBytesPreviouslyRead++;
933 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
934 assert(numBytesRead == (largeTestFileSize - (
int)totalBytesPreviouslyRead));
937 for(
int i = 0; i < numBytesRead - 5; i++)
939 assert(largeBuffer[i] ==
'0');
941 assert(largeBuffer[numBytesRead - 5] ==
'1');
942 assert(largeBuffer[numBytesRead - 4] ==
'2');
943 assert(largeBuffer[numBytesRead - 3] ==
'3');
944 assert(largeBuffer[numBytesRead - 2] ==
'4');
945 assert(largeBuffer[numBytesRead - 1] ==
'5');
947 totalBytesPreviouslyRead += numBytesRead;
950 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
951 assert(numBytesRead == 0);
953 assert(myCurrentBufferSize == 0);
954 assert(myBufferIndex == 0);
955 assert(
ifeof() != 0);
958 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
959 assert(numBytesRead == 0);
961 assert(myCurrentBufferSize == 0);
962 assert(myBufferIndex == 0);
963 assert(
ifeof() != 0);
967 totalBytesPreviouslyRead = 0;
968 assert(myCurrentBufferSize == 0);
969 assert(myBufferIndex == 0);
974 assert(readChar ==
'0');
975 bufferSize = DEFAULT_BUFFER_SIZE;
976 assert(myCurrentBufferSize == bufferSize);
977 assert(myBufferIndex == 1);
978 totalBytesPreviouslyRead++;
981 assert(readChar ==
'0');
982 assert(myCurrentBufferSize == bufferSize);
983 assert(myBufferIndex == 2);
984 totalBytesPreviouslyRead++;
987 numBytesRead =
ifread(myTestBuffer, 2);
988 assert(myTestBuffer[0] ==
'0');
989 assert(myTestBuffer[1] ==
'0');
990 assert(numBytesRead == 2);
991 totalBytesPreviouslyRead += numBytesRead;
993 assert(myCurrentBufferSize == bufferSize);
994 assert(myBufferIndex == totalBytesPreviouslyRead);
996 assert(
ifeof() ==
false);
1000 assert(readChar ==
'0');
1001 assert(myCurrentBufferSize == bufferSize);
1002 totalBytesPreviouslyRead++;
1003 assert(myBufferIndex == totalBytesPreviouslyRead);
1006 assert(readChar ==
'0');
1007 assert(myCurrentBufferSize == bufferSize);
1008 totalBytesPreviouslyRead++;
1009 assert(myBufferIndex == totalBytesPreviouslyRead);
1012 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
1013 assert(numBytesRead == (largeTestFileSize - (
int)totalBytesPreviouslyRead));
1015 for(
int i = 0; i < numBytesRead - 5; i++)
1017 assert(largeBuffer[i] ==
'0');
1020 assert(largeBuffer[numBytesRead - 5] ==
'1');
1021 assert(largeBuffer[numBytesRead - 5 + 1] ==
'2');
1022 assert(largeBuffer[numBytesRead - 5 + 2] ==
'3');
1023 assert(largeBuffer[numBytesRead - 5 + 3] ==
'4');
1024 assert(largeBuffer[numBytesRead - 5 + 4] ==
'5');
1025 totalBytesPreviouslyRead += numBytesRead;
1027 assert(myBufferIndex == bufferSize);
1028 assert(myCurrentBufferSize == bufferSize);
1031 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
1032 assert(numBytesRead == 0);
1034 assert(myCurrentBufferSize == 0);
1035 assert(myBufferIndex == 0);
1036 assert(
ifeof() != 0);
1039 numBytesRead =
ifread(largeBuffer, largeTestFileSize);
1040 assert(numBytesRead == 0);
1042 assert(myCurrentBufferSize == 0);
1043 assert(myBufferIndex == 0);
1044 assert(
ifeof() != 0);
1048 totalBytesPreviouslyRead = 0;
1049 assert(myCurrentBufferSize == 0);
1050 assert(myBufferIndex == 0);
1054 std::cout <<
" Passed test_ifread_ifgetc" << std::endl;
1059 void IFILE_Test::test_ifclose(
const char* extension)
1062 openFile(extension);
1065 assert(myFileTypePtr != NULL);
1067 assert(myFileTypePtr->isOpen());
1071 assert(myFileTypePtr == NULL);
1072 assert(
isOpen() ==
false);
1074 std::cout <<
" Passed test_ifclose" << std::endl;
1078 void IFILE_Test::test_ifseek(
const char* extension)
1082 openFile(extension);
1085 int numBytesRead = readFromFile(myTestBuffer, 1);
1086 assert(numBytesRead == 1);
1087 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[0]);
1090 long int currentPos =
iftell();
1093 numBytesRead = readFromFile(myTestBuffer, 1);
1094 assert(numBytesRead == 1);
1095 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[1]);
1099 assert(
ifseek(currentPos, SEEK_SET) ==
true);
1100 numBytesRead = readFromFile(myTestBuffer, 1);
1101 assert(numBytesRead == 1);
1102 assert(myTestBuffer[0] == TEST_FILE_CONTENTS[1]);
1106 assert(myFileTypePtr == NULL);
1107 assert(
isOpen() ==
false);
1112 std::cout <<
" Passed test_ifseek" << std::endl;
1115 void IFILE_Test::test_noExistRead(
const char* extension)
1117 openNoExistFile(extension);
1123 void IFILE_Test::openFile(
const char* extension)
1125 std::string filename =
"data/InputFileTest.";
1126 filename += extension;
1131 void IFILE_Test::openLargeFile(
const char* extension)
1133 std::string filename =
"data/InputFileTestLarge.";
1134 filename += extension;
1139 void IFILE_Test::openNoExistFile(
const char* extension)
1141 std::string filename =
"data/noExist.";
1142 filename += extension;
1149 std::string filenameNoExt =
"results/InputFileTest.";
1150 std::string filename = filenameNoExt +
"glf";
1153 assert(filePtr != NULL);
1156 IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1157 IFILE_Test::TEST_FILE_CONTENTS.length())
1158 == IFILE_Test::TEST_FILE_CONTENTS.length());
1160 assert(
ifclose(filePtr) == 0);
1162 filename =
"results/uncompressedFile.glf";
1165 assert(filePtr != NULL);
1168 IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1169 IFILE_Test::TEST_FILE_CONTENTS.length())
1170 == IFILE_Test::TEST_FILE_CONTENTS.length());
1172 assert(
ifclose(filePtr) == 0);
1174 filename =
"results/bgzfFile.glf";
1177 assert(filePtr != NULL);
1180 IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1181 IFILE_Test::TEST_FILE_CONTENTS.length())
1182 == IFILE_Test::TEST_FILE_CONTENTS.length());
1184 assert(
ifclose(filePtr) == 0);
1186 filename =
"results/gzipFile.glf";
1189 assert(filePtr != NULL);
1192 IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1193 IFILE_Test::TEST_FILE_CONTENTS.length())
1194 ==IFILE_Test:: TEST_FILE_CONTENTS.length());
1196 assert(
ifclose(filePtr) == 0);
1198 filename =
"results/defaultFile.glf";
1200 filePtr =
ifopen(filename.c_str(),
"wt");
1201 assert(filePtr != NULL);
1204 IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1205 IFILE_Test::TEST_FILE_CONTENTS.length())
1206 == IFILE_Test::TEST_FILE_CONTENTS.length());
1208 assert(
ifclose(filePtr) == 0);
1210 filename =
"results/defaultFile.gz";
1212 filePtr =
ifopen(filename.c_str(),
"wt");
1213 assert(filePtr != NULL);
1216 IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1217 IFILE_Test::TEST_FILE_CONTENTS.length())
1218 == IFILE_Test::TEST_FILE_CONTENTS.length());
1220 assert(
ifclose(filePtr) == 0);
1223 filename =
"results/textFile.gz";
1225 unsigned int myuint = 99;
1229 filePtr =
ifopen(filename.c_str(),
"wt");
1230 (*filePtr) <<
"Hello\n";
1231 (*filePtr) <<
"Hello." << 3 <<
' ' << -2 <<
"How are you";
1232 (*filePtr) <<
"?" <<
"\n";
1233 std::string mytext =
"Bye\n";
1234 (*filePtr) << mytext;
1235 (*filePtr) << 3.125 << mychar;
1236 (*filePtr) << myuint;
1237 (*filePtr) << mychar;
1238 (*filePtr) << myint;
1239 String myString =
"Good Bye!\n";
1240 (*filePtr) << myString;
1241 assert(
ifclose(filePtr) == 0);
1243 filename =
"results/textFile1.gz";
1245 fileRef <<
"Hello\n";
1246 fileRef <<
"Hello." << 3 <<
' ' << -2 <<
"How are you";
1247 fileRef <<
"?" <<
"\n";
1249 fileRef << 3.125 << mychar;
1253 fileRef << myString;
1255 assert(
ifclose(fileRefPtr) == 0);
1256 assert(fileRefPtr == NULL);
1264 void testAdditional(
const char* extension)
1266 std::string fileName =
"data/InputFileTest2.";
1267 fileName += extension;
1269 assert(testFile != NULL);
1271 std::string buffer =
"989";
1272 std::string stopChars =
"C5F2";
1275 assert(testFile->
readTilChar(stopChars, buffer) == 0);
1276 assert(buffer ==
"989AB");
1278 assert(testFile->
readTilChar(stopChars, buffer) == 2);
1279 assert(buffer ==
"DE");
1280 assert(testFile->
readTilChar(stopChars, buffer) == 3);
1281 assert(buffer ==
"DEG\tabcdefg\n1");
1288 assert(buffer ==
"t6");
1290 assert(buffer ==
"t6hijklm");
1292 assert(buffer ==
"t6hijklm1");
1294 assert(buffer ==
"t6hijklm1NOP");
1295 assert(testFile->
readLine(buffer) == 0);
1296 assert(buffer ==
"t6hijklm1NOPQRST\tUVW");
1298 assert(buffer ==
"t6hijklm1NOPQRST\tUVW");
1301 assert(testFile->
readLine(buffer) == -1);
1302 assert(buffer ==
"@#$");
1305 assert(testFile->
readTilChar(stopChars, buffer) == -1);
1307 assert(buffer ==
"@#$");