libStatGen Software  1
InputFileTest.cpp
1 /*
2  * Copyright (C) 2010 Regents of the University of Michigan
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  */
17 #include "InputFileTest.h"
18 #include <assert.h>
19 #include <iostream>
20 #include "StringBasics.h"
21 
22 void testAdditional(const char *extension);
23 void testWrite();
24 
25 
26 int main(int argc, char ** argv)
27 {
28  IFILE_Test myFile;
29 
30  myFile.test();
31 
32  testWrite();
33 
34  std::cout << "\nAdditional Tests: " << std::endl;
35 
36  testAdditional("txt");
37 #ifdef __ZLIB_AVAILABLE__
38  testAdditional("gz");
39 #endif
40 }
41 
42 
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";
46 
47 void IFILE_Test::test()
48 {
49  std::cout << "\nUncompressedFileType Tests:" << std::endl;
50  testAll("txt");
51 
52 #ifdef __ZLIB_AVAILABLE__
53  std::cout << "\nGzipFileType Tests:" << std::endl;
54  testAll("gz");
55 
56  std::cout << "\nBgzfFileType Tests:" << std::endl;
57  testAll("bam");
58 
59  std::cout << "\n.glf file Tests:" << std::endl;
60  testAll("glf");
61 #endif
62 }
63 
64 
65 void IFILE_Test::testAll(const char* extension)
66 {
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);
74 }
75 
76 
77 void IFILE_Test::test_readFromFile(const char* extension)
78 {
79  // First open the test file.
80  openFile(extension);
81 
82  // Verify the file successfully opened.
83  assert(myFileTypePtr != NULL);
84  assert(isOpen());
85  assert(myFileTypePtr->isOpen());
86 
87  // Track how many bytes are read by each call.
88  int numBytesRead = 0;
89 
90  // Track the total number of the bytes that have been read from the file
91  // at any given point.
92  int totalBytesPreviouslyRead = 0;
93 
94  // Test readFromFile.
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;
102  // This read should not have affected the internal buffer.
103  assert(myCurrentBufferSize == 0);
104  assert(myBufferIndex == 0);
105  // Should not be at eof
106  assert(myFileTypePtr->eof() == false);
107  assert(ifeof() == false);
108 
109  // Read again to verify that the next characters could be read.
110  numBytesRead = readFromFile(myTestBuffer, 2);
111  // Read 2 more characters from the test file.
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;
118  // This read should not have affected the internal buffer.
119  assert(myCurrentBufferSize == 0);
120  assert(myBufferIndex == 0);
121  // Should not be at eof
122  assert(myFileTypePtr->eof() == false);
123  assert(ifeof() == false);
124 
125  // Read the rest of the file.
126  // Determine expected results for reading the rest of the file by
127  // taking the substring starting after what had been previously read.
128  numBytesRead = readFromFile(myTestBuffer, MAX_TEST_BUFFER_SIZE);
129  // Read the rest of the file, so the number of bytes read is
130  // what was left in the file.
131  assert(numBytesRead == (TEST_FILE_SIZE - totalBytesPreviouslyRead));
132  assert(numBytesRead != MAX_TEST_BUFFER_SIZE);
133  for(int i = 0; i < numBytesRead; i++)
134  {
135  assert(myTestBuffer[i] ==
136  TEST_FILE_CONTENTS[totalBytesPreviouslyRead+i]);
137  }
138  totalBytesPreviouslyRead += numBytesRead;
139  assert(myFileTypePtr->eof() != 0);
140  assert(ifeof() != 0);
141 
142  // Try to read one more time, making sure it doesn't read anything.
143  numBytesRead = readFromFile(myTestBuffer, MAX_TEST_BUFFER_SIZE);
144  assert(numBytesRead == 0);
145  // Should be at eof
146  assert(myFileTypePtr->eof() != 0);
147  assert(ifeof() != 0);
148 
149  ifclose();
150 
151  std::cout << " Passed test_readFromFile" << std::endl;
152 }
153 
154 
155 
156 
157 void IFILE_Test::test_readTilChar(const char* extension)
158 {
159  // First open the test file.
160  openFile(extension);
161 
162  // Verify the file successfully opened.
163  assert(myFileTypePtr != NULL);
164  assert(isOpen());
165  assert(myFileTypePtr->isOpen());
166 
167  // Track position of ending char found.
168  int pos = 0;
169 
170  // Test readTilChar.
171  std::string output = "";
172  std::string endChars = "a5d";
173  pos = readTilChar(endChars, output);
174  assert(pos == 0); // read til a
175  assert(output == "ABCD");
176  output.clear();
177  pos = readTilChar(endChars, output);
178  assert(pos == 2); // read til d
179  assert(output == "bc");
180  pos = readTilChar(endChars, output);
181  assert(pos == 1); // read til 5
182  assert(output == "bc1234\nEFGefg");
183  output.clear();
184  pos = readTilChar(endChars, output);
185  assert(pos == -1); // read til 5
186  assert(output == "67\nhijklHIJKL8910");
187 
188  ifrewind();
189  // Test readTilChar.
190  pos = readTilChar(endChars);
191  assert(pos == 0); // read til a
192  pos = readTilChar(endChars);
193  assert(pos == 2); // read til d
194  pos = readTilChar(endChars);
195  assert(pos == 1); // read til 5
196  pos = readTilChar(endChars);
197  assert(pos == -1); // read til 5
198 
199  ifclose();
200 
201  std::cout << " Passed test_readTilChar" << std::endl;
202 }
203 
204 
205 void IFILE_Test::test_ifeof_ifrewind(const char* extension)
206 {
207  // First open the test file.
208  openFile(extension);
209 
210  // Verify the file successfully opened.
211  assert(myFileTypePtr != NULL);
212  assert(isOpen());
213  assert(myFileTypePtr->isOpen());
214 
215  // Not at eof - verify that it reports not eof.
216  assert(ifeof() == false);
217 
218  // Track the total number of the bytes that have been read from the file
219  // at any given point.
220  int totalBytesPreviouslyRead = 0;
221  int numBytesRead = 0;
222 
223  //////////////////////////////////////////////////////////////
224  // Test doing reads from file without IFILE internal buffering.
226 
227  // Verify position in file.
228  assert(iftell() == 0);
229 
230  // Read a character from the file.
231  numBytesRead = readFromFile(myTestBuffer, 1);
232  assert(numBytesRead == 1);
233  assert(myTestBuffer[0] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
234  // Now that we have tested based on the previous total bytes read,
235  // increment the count.
236  totalBytesPreviouslyRead += numBytesRead;
237  // Not at eof
238  assert(ifeof() == false);
239 
240  // Perform char read.
241  char readChar = ifgetc();
242  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
243  // Now that we have tested based on the previous total bytes read,
244  // increment the count.
245  ++totalBytesPreviouslyRead;
246  // Not at eof
247  assert(ifeof() == false);
248  assert(iftell() == totalBytesPreviouslyRead);
249 
250  // Now read the rest.
251  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
252  assert(numBytesRead == (TEST_FILE_SIZE - totalBytesPreviouslyRead));
253  // Hit the end of the file before reading the entire requested size.
254  assert(numBytesRead != MAX_TEST_BUFFER_SIZE);
255  // Now that we have tested based on the previous total bytes read,
256  // increment the count.
257  totalBytesPreviouslyRead += numBytesRead;
258 
259  assert(myFileTypePtr->eof() != 0);
260  assert(ifeof() != 0);
261 
262  numBytesRead = readFromFile(myTestBuffer, 1);
263  assert(numBytesRead == 0);
264  // Now it registers eof
265  assert(ifeof() != 0);
266 
267  // bgzf files use a specialized return value for iftell that
268  // is not just straight file offset.
269  if((strcmp(extension, "bam") == 0) || (strcmp(extension, "glf") == 0))
270  {
271  assert(iftell() == (BGZF_TEST_FILE_SIZE << 16));
272  }
273  else
274  {
275  assert(iftell() == TEST_FILE_SIZE);
276  }
277 
278  ///////////////////////////////////
279  // Test doing IFILE buffered reads.
280  // rewind the file and verify that it no longer registers eof.
281  ifrewind();
282  totalBytesPreviouslyRead = 0;
283  // No longer at eof
284  assert(ifeof() == false);
285  // Verify position in file.
286  assert(iftell() == 0);
287 
288  // Buffer reads - may have been disabled for iftell to work for bgzf.
289  bufferReads();
290 
291  // Read a character from the file.
292  numBytesRead = readFromFile(myTestBuffer, 1);
293  assert(numBytesRead == 1);
294  assert(myTestBuffer[0] == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
295  // Now that we have tested based on the previous total bytes read,
296  // increment the count.
297  totalBytesPreviouslyRead += numBytesRead;
298  // Not at eof
299  assert(ifeof() == false);
300 
301  // Perform char read.
302  readChar = ifgetc();
303  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
304  // Now that we have tested based on the previous total bytes read,
305  // increment the count.
306  ++totalBytesPreviouslyRead;
307  // Not at eof
308  assert(ifeof() == false);
309 
310  // bgzf files use a specialized return value for iftell that
311  // is not just straight file offset.
312  if((strcmp(extension, "bam") == 0) || (strcmp(extension, "glf") == 0))
313  {
314  bool caught = false;
315  try
316  {
317  assert(iftell() == totalBytesPreviouslyRead);
318  }
319  catch (std::exception& e)
320  {
321  caught = true;
322  assert(strcmp(e.what(), "IFILE: CANNOT use buffered reads and tell for BGZF files") == 0);
323  }
324  assert(caught);
325  }
326  else
327  {
328  assert(iftell() == totalBytesPreviouslyRead);
329  }
330 
331  // Now read the rest.
332  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
333  assert(numBytesRead == (TEST_FILE_SIZE - totalBytesPreviouslyRead));
334  // Now that we have tested based on the previous total bytes read,
335  // increment the count.
336  totalBytesPreviouslyRead += numBytesRead;
337  // Registers eof.
338  assert(ifeof() != 0);
339 
340  // Read past eof.
341  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
342  assert(numBytesRead == 0);
343  // Eof.
344  assert(ifeof() != 0);
345 
346  // bgzf files use a specialized return value for iftell that
347  // is not just straight file offset.
348  if((strcmp(extension, "bam") == 0) || (strcmp(extension, "glf") == 0))
349  {
350  bool caught = false;
351  try
352  {
353  assert(iftell() == (BGZF_TEST_FILE_SIZE << 16));
354  }
355  catch (std::exception& e)
356  {
357  caught = true;
358  assert(strcmp(e.what(), "IFILE: CANNOT use buffered reads and tell for BGZF files") == 0);
359  }
360  assert(caught);
362  assert(iftell() == (BGZF_TEST_FILE_SIZE << 16));
363  }
364  else
365  {
366  assert(iftell() == TEST_FILE_SIZE);
367  }
368 
369  // Verify that after rewind, eof is no longer registered.
370  ifrewind();
371  // reset since we are back to the beginning of the file.
372  totalBytesPreviouslyRead = 0;
373  // No longer at eof
374  assert(ifeof() == false);
375  // Verify position in file.
376  assert(iftell() == 0);
377 
378  // Verify properly works even if already at the beginning.
379  ifrewind();
380  // reset since we are back to the beginning of the file.
381  totalBytesPreviouslyRead = 0;
382  // Not eof
383  assert(ifeof() == false);
384  // Verify position in file.
385  assert(iftell() == 0);
386 
387  // Buffer reads - may have been disabled for iftell to work for bgzf.
388  bufferReads();
389 
390  //////////////////////
391  // Close the test file.
392  ifclose();
393 
394  std::cout << " Passed test_ifeof_ifrewind" << std::endl;
395 }
396 
397 
398 void IFILE_Test::test_ifread_ifgetc(const char* extension)
399 {
400  // First open the test file.
401  openFile(extension);
402 
403  // Verify the file successfully opened.
404  assert(myFileTypePtr != NULL);
405  assert(isOpen());
406  assert(myFileTypePtr->isOpen());
407 
408  int numBytesRead = 0;
409  int totalBytesPreviouslyRead = 0;
410 
411  ////////////////////////////////////
412  // Test reading entire file at once.
413  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
414  assert(numBytesRead == TEST_FILE_SIZE);
415 
416  for(int i = 0; i < TEST_FILE_SIZE; i++)
417  {
418  assert(myTestBuffer[i] == TEST_FILE_CONTENTS[i]);
419  }
420  totalBytesPreviouslyRead += numBytesRead;
421 
422  // Should affect the IFILE buffer
423  assert(myCurrentBufferSize == TEST_FILE_SIZE);
424  assert(myBufferIndex == TEST_FILE_SIZE);
425 
426  assert(myFileTypePtr->eof() != 0);
427  assert(ifeof() != 0);
428 
429  // Try reading at end of file twice.
430  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
431  assert(numBytesRead == 0);
432  // Should affect the IFILE buffer
433  assert(myCurrentBufferSize == 0);
434  assert(myBufferIndex == 0);
435  assert(ifeof() != 0);
436 
437  // 2nd read attempt at eof.
438  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
439  assert(numBytesRead == 0);
440  // Should affect the IFILE buffer
441  assert(myCurrentBufferSize == 0);
442  assert(myBufferIndex == 0);
443  assert(ifeof() != 0);
444 
445 
446  // RESET
447  ifrewind();
448  totalBytesPreviouslyRead = 0;
449 
450  //////////////////////////////////////////
451  // Test reading entire file using getc.
452  // Loop through reading the file.
453  char readChar;
454  for(int index = 0; index < TEST_FILE_SIZE; index++)
455  {
456  // Read a character.
457  readChar = ifgetc();
458  assert(readChar == TEST_FILE_CONTENTS[index]);
459  // Should affect the IFILE buffer
460  assert(myCurrentBufferSize == TEST_FILE_SIZE);
461  assert(myBufferIndex == index+1);
462  }
463 
464  // Now that we have read the file, try reading again at eof.
465  readChar = ifgetc();
466  assert(readChar == EOF);
467  assert(myCurrentBufferSize == 0);
468  assert(myBufferIndex == 0);
469 
470  // Try again at eof.
471  // Now that we have read the file, try reading again at eof.
472  readChar = ifgetc();
473  assert(readChar == EOF);
474  assert(myCurrentBufferSize == 0);
475  assert(myBufferIndex == 0);
476 
477  // RESET
478  ifrewind();
479  totalBytesPreviouslyRead = 0;
480 
481  ////////////////////////////////////////////////
482  // Test reading just the beginning of the file.
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;
490  // This read should have affected the internal buffer.
491  assert(myCurrentBufferSize == TEST_FILE_SIZE);
492  assert(myBufferIndex == 4);
493  // Should not be at eof
494  assert(ifeof() == false);
495 
496  // Test reading rest of file.
497  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
498  assert(numBytesRead == (TEST_FILE_SIZE - (int)totalBytesPreviouslyRead));
499  // Verify contents of what read.
500  for(int i = 0; i < numBytesRead; i++)
501  {
502  assert(myTestBuffer[i] ==
503  TEST_FILE_CONTENTS[i + totalBytesPreviouslyRead]);
504  }
505  totalBytesPreviouslyRead += numBytesRead;
506 
507  // Try at end of file twice.
508  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
509  assert(numBytesRead == 0);
510  // Should affect the IFILE buffer
511  assert(myCurrentBufferSize == 0);
512  assert(myBufferIndex == 0);
513  assert(ifeof() != 0);
514 
515  // 2nd read attempt at eof.
516  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
517  assert(numBytesRead == 0);
518  // Should affect the IFILE buffer
519  assert(myCurrentBufferSize == 0);
520  assert(myBufferIndex == 0);
521  assert(ifeof() != 0);
522 
523  // RESET
524  ifrewind();
525  totalBytesPreviouslyRead = 0;
526 
527  //////////////////////////////////////
528  // Test reading just the beginning.
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;
536  // This read should have affected the internal buffer.
537  assert(myCurrentBufferSize == TEST_FILE_SIZE);
538  assert(myBufferIndex == 4);
539  // Should not be at eof
540  assert(ifeof() == false);
541 
542  // Test doing 2 getc.
543  readChar = ifgetc();
544  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
545  int bufferSize = TEST_FILE_SIZE;
546  assert(myCurrentBufferSize == bufferSize);
547  assert(myBufferIndex == 5);
548  totalBytesPreviouslyRead++;
549 
550  readChar = ifgetc();
551  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
552  assert(myCurrentBufferSize == bufferSize);
553  assert(myBufferIndex == 6);
554  totalBytesPreviouslyRead++;
555 
556  // Test reading rest of file.
557  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
558  assert(numBytesRead == (TEST_FILE_SIZE - (int)totalBytesPreviouslyRead));
559  // Verify contents of what read.
560  for(int i = 0; i < numBytesRead; i++)
561  {
562  assert(myTestBuffer[i] ==
563  TEST_FILE_CONTENTS[i + totalBytesPreviouslyRead]);
564  }
565  totalBytesPreviouslyRead += numBytesRead;
566 
567  // Try at end of file twice.
568  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
569  assert(numBytesRead == 0);
570  // Should affect the IFILE buffer
571  assert(myCurrentBufferSize == 0);
572  assert(myBufferIndex == 0);
573  assert(ifeof() != 0);
574 
575  // 2nd read attempt at eof.
576  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
577  assert(numBytesRead == 0);
578  // Should affect the IFILE buffer
579  assert(myCurrentBufferSize == 0);
580  assert(myBufferIndex == 0);
581  assert(ifeof() != 0);
582 
583  // RESET
584  ifrewind();
585  totalBytesPreviouslyRead = 0;
586  assert(myCurrentBufferSize == 0);
587  assert(myBufferIndex == 0);
588 
589  //////////////////////////////////
590  // Start with 2 getc.
591  readChar = ifgetc();
592  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
593  bufferSize = TEST_FILE_SIZE;
594  assert(myCurrentBufferSize == bufferSize);
595  assert(myBufferIndex == 1);
596  totalBytesPreviouslyRead++;
597 
598  readChar = ifgetc();
599  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
600  assert(myCurrentBufferSize == bufferSize);
601  assert(myBufferIndex == 2);
602  totalBytesPreviouslyRead++;
603 
604  // Test reading part of the rest of the file.
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;
612  // This read should have affected the internal buffer.
613  assert(myCurrentBufferSize == bufferSize);
614  assert(myBufferIndex == totalBytesPreviouslyRead);
615  // Should not be at eof
616  assert(ifeof() == false);
617 
618  // Test reading 2 char with getc.
619  readChar = ifgetc();
620  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
621  assert(myCurrentBufferSize == bufferSize);
622  totalBytesPreviouslyRead++;
623  assert(myBufferIndex == totalBytesPreviouslyRead);
624 
625  readChar = ifgetc();
626  assert(readChar == TEST_FILE_CONTENTS[totalBytesPreviouslyRead]);
627  assert(myCurrentBufferSize == bufferSize);
628  totalBytesPreviouslyRead++;
629  assert(myBufferIndex == totalBytesPreviouslyRead);
630 
631  // Test reading rest of file.
632  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
633  assert(numBytesRead == (TEST_FILE_SIZE - (int)totalBytesPreviouslyRead));
634  // Verify contents of what read.
635  for(int i = 0; i < numBytesRead; i++)
636  {
637  assert(myTestBuffer[i] ==
638  TEST_FILE_CONTENTS[i + totalBytesPreviouslyRead]);
639  }
640  totalBytesPreviouslyRead += numBytesRead;
641  assert(myBufferIndex == 0);
642  assert(myCurrentBufferSize == 0);
643 
644  // Try at end of file twice.
645  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
646  assert(numBytesRead == 0);
647  // Should affect the IFILE buffer
648  assert(myCurrentBufferSize == 0);
649  assert(myBufferIndex == 0);
650  assert(ifeof() != 0);
651 
652  // 2nd read attempt at eof.
653  numBytesRead = ifread(myTestBuffer, MAX_TEST_BUFFER_SIZE);
654  assert(numBytesRead == 0);
655  // Should affect the IFILE buffer
656  assert(myCurrentBufferSize == 0);
657  assert(myBufferIndex == 0);
658  assert(ifeof() != 0);
659 
660  // RESET
661  ifrewind();
662  totalBytesPreviouslyRead = 0;
663  assert(myCurrentBufferSize == 0);
664  assert(myBufferIndex == 0);
665 
666  //////////////
667  // Close the test file.
668  ifclose();
669 
670  ////////////////////////////////////////////////////////////////////////
671  // Repeat the test on a test file that is larger than the IFILE
672  // buffer size.
673 
674  // First open the test file.
675  openLargeFile(extension);
676 
677  // This file contains DEFAULT_BUFFER_SIZE of '0's followed by "12345"
678  // The size of the file is DEFAULT_BUFFER_SIZE + 5.
679  int largeTestFileSize = DEFAULT_BUFFER_SIZE + 5;
680  char largeBuffer[largeTestFileSize + 5];
681 
682  // Verify the file successfully opened.
683  assert(myFileTypePtr != NULL);
684  assert(isOpen());
685  assert(myFileTypePtr->isOpen());
686 
687  numBytesRead = 0;
688  totalBytesPreviouslyRead = 0;
689 
690  ////////////////////////////////////
691  // Test reading part of the file, then more then the buffer size,
692  // then the rest of the file (test buffer handling when read
693  // available and directly into the file, then read more).
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);
698  // Should be at the end of the file.
699  assert(myFileTypePtr->eof() != 0);
700  assert(ifeof() != 0);
701  numBytesRead = ifread(largeBuffer + DEFAULT_BUFFER_SIZE + 3, 2);
702  assert(numBytesRead == 0);
703 
704  // Validate all the 0s
705  for(unsigned int i = 0; i < DEFAULT_BUFFER_SIZE; i++)
706  {
707  assert(largeBuffer[i] == '0');
708  }
709  // Now validate the "12345"
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');
715 
716  totalBytesPreviouslyRead += numBytesRead;
717 
718  // Should affect the IFILE buffer - 0 because read
719  // is bigger than the buffer, so just read directly
720  // into the largeBuffer.
721  assert(myCurrentBufferSize == 0);
722  assert(myBufferIndex == 0);
723 
724  assert(myFileTypePtr->eof() != 0);
725  assert(ifeof() != 0);
726 
727  // Try reading at end of file twice.
728  numBytesRead = ifread(largeBuffer, largeTestFileSize);
729  assert(numBytesRead == 0);
730  // Should affect the IFILE buffer
731  assert(myCurrentBufferSize == 0);
732  assert(myBufferIndex == 0);
733  assert(ifeof() != 0);
734 
735  // 2nd read attempt at eof.
736  numBytesRead = ifread(largeBuffer, largeTestFileSize);
737  assert(numBytesRead == 0);
738  // Should affect the IFILE buffer
739  assert(myCurrentBufferSize == 0);
740  assert(myBufferIndex == 0);
741  assert(ifeof() != 0);
742 
743 
744  // RESET
745  ifrewind();
746  totalBytesPreviouslyRead = 0;
747 
748  ////////////////////////////////////
749  // Test reading entire file at once.
750  numBytesRead = ifread(largeBuffer, largeTestFileSize + 4);
751  assert(numBytesRead == largeTestFileSize);
752 
753  // Validate all the 0s
754  for(unsigned int i = 0; i < DEFAULT_BUFFER_SIZE; i++)
755  {
756  assert(largeBuffer[i] == '0');
757  }
758  // Now validate the "12345"
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');
764 
765  totalBytesPreviouslyRead += numBytesRead;
766 
767  // Should affect the IFILE buffer - 0 because read
768  // is bigger than the buffer, so just read directly
769  // into the largeBuffer.
770  assert(myCurrentBufferSize == 0);
771  assert(myBufferIndex == 0);
772 
773  assert(myFileTypePtr->eof() != 0);
774  assert(ifeof() != 0);
775 
776  // Try reading at end of file twice.
777  numBytesRead = ifread(largeBuffer, largeTestFileSize);
778  assert(numBytesRead == 0);
779  // Should affect the IFILE buffer
780  assert(myCurrentBufferSize == 0);
781  assert(myBufferIndex == 0);
782  assert(ifeof() != 0);
783 
784  // 2nd read attempt at eof.
785  numBytesRead = ifread(largeBuffer, largeTestFileSize);
786  assert(numBytesRead == 0);
787  // Should affect the IFILE buffer
788  assert(myCurrentBufferSize == 0);
789  assert(myBufferIndex == 0);
790  assert(ifeof() != 0);
791 
792 
793  // RESET
794  ifrewind();
795  totalBytesPreviouslyRead = 0;
796 
797  //////////////////////////////////////////
798  // Test reading entire file using getc.
799  // Loop through reading the file.
800  // First loop through verifying the 0's
801  for(int index = 0; index < (int)DEFAULT_BUFFER_SIZE; index++)
802  {
803  // Read a character.
804  readChar = ifgetc();
805  assert(readChar == '0');
806  // Should affect the IFILE buffer
807  assert(myCurrentBufferSize == (int)DEFAULT_BUFFER_SIZE);
808  assert(myBufferIndex == index+1);
809  }
810  // Now read the 12345.
811  readChar = ifgetc();
812  assert(readChar == '1');
813  // Should affect the IFILE buffer
814  assert(myCurrentBufferSize == 5);
815  assert(myBufferIndex == 1);
816  readChar = ifgetc();
817  assert(readChar == '2');
818  // Should affect the IFILE buffer
819  assert(myCurrentBufferSize == 5);
820  assert(myBufferIndex == 2);
821  readChar = ifgetc();
822  assert(readChar == '3');
823  // Should affect the IFILE buffer
824  assert(myCurrentBufferSize == 5);
825  assert(myBufferIndex == 3);
826  readChar = ifgetc();
827  assert(readChar == '4');
828  // Should affect the IFILE buffer
829  assert(myCurrentBufferSize == 5);
830  assert(myBufferIndex == 4);
831  readChar = ifgetc();
832  assert(readChar == '5');
833  // Should affect the IFILE buffer
834  assert(myCurrentBufferSize == 5);
835  assert(myBufferIndex == 5);
836 
837  // Now that we have read the file, try reading again at eof.
838  readChar = ifgetc();
839  assert(readChar == EOF);
840  assert(myCurrentBufferSize == 0);
841  assert(myBufferIndex == 0);
842 
843  // Try again at eof.
844  // Now that we have read the file, try reading again at eof.
845  readChar = ifgetc();
846  assert(readChar == EOF);
847  assert(myCurrentBufferSize == 0);
848  assert(myBufferIndex == 0);
849 
850  // RESET
851  ifrewind();
852  totalBytesPreviouslyRead = 0;
853 
854  ////////////////////////////////////////////////
855  // Test reading just the beginning of the file.
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;
863  // This read should have affected the internal buffer.
864  assert(myCurrentBufferSize == (int)DEFAULT_BUFFER_SIZE);
865  assert(myBufferIndex == 4);
866  // Should not be at eof
867  assert(ifeof() == false);
868 
869  // Test reading rest of file.
870  numBytesRead = ifread(largeBuffer, largeTestFileSize);
871  assert(numBytesRead == (largeTestFileSize - (int)totalBytesPreviouslyRead));
872  // Verify contents of what read. First check the 0's
873  for(int i = 0; i < (numBytesRead-5); i++)
874  {
875  assert(largeBuffer[i] == '0');
876  }
877  // Check the 12345
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;
884 
885  // Try at end of file twice.
886  numBytesRead = ifread(largeBuffer, largeTestFileSize);
887  assert(numBytesRead == 0);
888  // Trying to read at the end cleared the buffer..
889  assert(myCurrentBufferSize == 0);
890  assert(myBufferIndex == 0);
891  assert(ifeof() != 0);
892 
893  // 2nd read attempt at eof.
894  numBytesRead = ifread(largeBuffer, largeTestFileSize);
895  assert(numBytesRead == 0);
896  // Should affect the IFILE buffer
897  assert(myCurrentBufferSize == 0);
898  assert(myBufferIndex == 0);
899  assert(ifeof() != 0);
900 
901  // RESET
902  ifrewind();
903  totalBytesPreviouslyRead = 0;
904 
905  //////////////////////////////////////
906  // Test reading just the beginning.
907  numBytesRead = ifread(largeBuffer, 2);
908  assert(largeBuffer[0] == '0');
909  assert(largeBuffer[1] == '0');
910  assert(numBytesRead == 2);
911  totalBytesPreviouslyRead += numBytesRead;
912  // This read should have affected the internal buffer.
913  assert(myCurrentBufferSize == (int)DEFAULT_BUFFER_SIZE);
914  assert(myBufferIndex == 2);
915  // Should not be at eof
916  assert(ifeof() == false);
917 
918  // Test doing 2 getc.
919  readChar = ifgetc();
920  assert(readChar == '0');
921  bufferSize = DEFAULT_BUFFER_SIZE;
922  assert(myCurrentBufferSize == bufferSize);
923  assert(myBufferIndex == 3);
924  totalBytesPreviouslyRead++;
925 
926  readChar = ifgetc();
927  assert(readChar == '0');
928  assert(myCurrentBufferSize == bufferSize);
929  assert(myBufferIndex == 4);
930  totalBytesPreviouslyRead++;
931 
932  // Test reading rest of file.
933  numBytesRead = ifread(largeBuffer, largeTestFileSize);
934  assert(numBytesRead == (largeTestFileSize - (int)totalBytesPreviouslyRead));
935  // Verify contents of what read.
936  // All except the last 5 should be '0'
937  for(int i = 0; i < numBytesRead - 5; i++)
938  {
939  assert(largeBuffer[i] == '0');
940  }
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');
946 
947  totalBytesPreviouslyRead += numBytesRead;
948 
949  // Try at end of file twice.
950  numBytesRead = ifread(largeBuffer, largeTestFileSize);
951  assert(numBytesRead == 0);
952  // Reading at the end clears the buffer
953  assert(myCurrentBufferSize == 0);
954  assert(myBufferIndex == 0);
955  assert(ifeof() != 0);
956 
957  // 2nd read attempt at eof.
958  numBytesRead = ifread(largeBuffer, largeTestFileSize);
959  assert(numBytesRead == 0);
960  // Reading at the end clears the buffer
961  assert(myCurrentBufferSize == 0);
962  assert(myBufferIndex == 0);
963  assert(ifeof() != 0);
964 
965  // RESET
966  ifrewind();
967  totalBytesPreviouslyRead = 0;
968  assert(myCurrentBufferSize == 0);
969  assert(myBufferIndex == 0);
970 
971  //////////////////////////////////
972  // Start with 2 getc.
973  readChar = ifgetc();
974  assert(readChar == '0');
975  bufferSize = DEFAULT_BUFFER_SIZE;
976  assert(myCurrentBufferSize == bufferSize);
977  assert(myBufferIndex == 1);
978  totalBytesPreviouslyRead++;
979 
980  readChar = ifgetc();
981  assert(readChar == '0');
982  assert(myCurrentBufferSize == bufferSize);
983  assert(myBufferIndex == 2);
984  totalBytesPreviouslyRead++;
985 
986  // Test reading part of the rest of the file.
987  numBytesRead = ifread(myTestBuffer, 2);
988  assert(myTestBuffer[0] == '0');
989  assert(myTestBuffer[1] == '0');
990  assert(numBytesRead == 2);
991  totalBytesPreviouslyRead += numBytesRead;
992  // This read should have affected the internal buffer.
993  assert(myCurrentBufferSize == bufferSize);
994  assert(myBufferIndex == totalBytesPreviouslyRead);
995  // Should not be at eof
996  assert(ifeof() == false);
997 
998  // Test reading 2 char with getc.
999  readChar = ifgetc();
1000  assert(readChar == '0');
1001  assert(myCurrentBufferSize == bufferSize);
1002  totalBytesPreviouslyRead++;
1003  assert(myBufferIndex == totalBytesPreviouslyRead);
1004 
1005  readChar = ifgetc();
1006  assert(readChar == '0');
1007  assert(myCurrentBufferSize == bufferSize);
1008  totalBytesPreviouslyRead++;
1009  assert(myBufferIndex == totalBytesPreviouslyRead);
1010 
1011  // Test reading rest of file.
1012  numBytesRead = ifread(largeBuffer, largeTestFileSize);
1013  assert(numBytesRead == (largeTestFileSize - (int)totalBytesPreviouslyRead));
1014  // Verify contents of what read.
1015  for(int i = 0; i < numBytesRead - 5; i++)
1016  {
1017  assert(largeBuffer[i] == '0');
1018  }
1019  // Verify the 12345
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;
1026  bufferSize = 5;
1027  assert(myBufferIndex == bufferSize);
1028  assert(myCurrentBufferSize == bufferSize);
1029 
1030  // Try at end of file twice.
1031  numBytesRead = ifread(largeBuffer, largeTestFileSize);
1032  assert(numBytesRead == 0);
1033  // Reading at the end clears the buffer
1034  assert(myCurrentBufferSize == 0);
1035  assert(myBufferIndex == 0);
1036  assert(ifeof() != 0);
1037 
1038  // 2nd read attempt at eof.
1039  numBytesRead = ifread(largeBuffer, largeTestFileSize);
1040  assert(numBytesRead == 0);
1041  // Reading at the end clears the buffer
1042  assert(myCurrentBufferSize == 0);
1043  assert(myBufferIndex == 0);
1044  assert(ifeof() != 0);
1045 
1046  // RESET
1047  ifrewind();
1048  totalBytesPreviouslyRead = 0;
1049  assert(myCurrentBufferSize == 0);
1050  assert(myBufferIndex == 0);
1051 
1052  ifclose();
1053 
1054  std::cout << " Passed test_ifread_ifgetc" << std::endl;
1055 }
1056 
1057 
1058 // Test closing a file.
1059 void IFILE_Test::test_ifclose(const char* extension)
1060 {
1061  // First open the test file.
1062  openFile(extension);
1063 
1064  // Verify the file successfully opened.
1065  assert(myFileTypePtr != NULL);
1066  assert(isOpen());
1067  assert(myFileTypePtr->isOpen());
1068 
1069  ifclose();
1070 
1071  assert(myFileTypePtr == NULL);
1072  assert(isOpen() == false);
1073 
1074  std::cout << " Passed test_ifclose" << std::endl;
1075 }
1076 
1077 
1078 void IFILE_Test::test_ifseek(const char* extension)
1079 {
1080  disableBuffering();
1081  // First open the test file.
1082  openFile(extension);
1083 
1084  // Read a character from the file.
1085  int numBytesRead = readFromFile(myTestBuffer, 1);
1086  assert(numBytesRead == 1);
1087  assert(myTestBuffer[0] == TEST_FILE_CONTENTS[0]);
1088 
1089  // Get the current position.
1090  long int currentPos = iftell();
1091 
1092  // Read the next character from the file.
1093  numBytesRead = readFromFile(myTestBuffer, 1);
1094  assert(numBytesRead == 1);
1095  assert(myTestBuffer[0] == TEST_FILE_CONTENTS[1]);
1096 
1097  // Seek to just before the character that was just read and read again
1098  // Should be the same character.
1099  assert(ifseek(currentPos, SEEK_SET) == true);
1100  numBytesRead = readFromFile(myTestBuffer, 1);
1101  assert(numBytesRead == 1);
1102  assert(myTestBuffer[0] == TEST_FILE_CONTENTS[1]);
1103 
1104  ifclose();
1105 
1106  assert(myFileTypePtr == NULL);
1107  assert(isOpen() == false);
1108 
1109  // Buffer reads - may have been disabled for iftell to work for bgzf.
1110  bufferReads();
1111 
1112  std::cout << " Passed test_ifseek" << std::endl;
1113 }
1114 
1115 void IFILE_Test::test_noExistRead(const char* extension)
1116 {
1117  openNoExistFile(extension);
1118 
1119 }
1120 
1121 
1122 // Open a file for testing.
1123 void IFILE_Test::openFile(const char* extension)
1124 {
1125  std::string filename = "data/InputFileTest.";
1126  filename += extension;
1127  assert(InputFile::openFile(filename.c_str(), "rb", InputFile::DEFAULT) == true);
1128 }
1129 
1130 // Open a file for testing.
1131 void IFILE_Test::openLargeFile(const char* extension)
1132 {
1133  std::string filename = "data/InputFileTestLarge.";
1134  filename += extension;
1135  assert(InputFile::openFile(filename.data(), "rb", InputFile::DEFAULT) == true);
1136 }
1137 
1138 
1139 void IFILE_Test::openNoExistFile(const char* extension)
1140 {
1141  std::string filename = "data/noExist.";
1142  filename += extension;
1143  assert(InputFile::openFile(filename.data(), "rb", InputFile::DEFAULT) == false);
1144 }
1145 
1146 
1147 void testWrite()
1148 {
1149  std::string filenameNoExt = "results/InputFileTest.";
1150  std::string filename = filenameNoExt + "glf";
1151 
1152  IFILE filePtr = ifopen(filename.c_str(), "wt");
1153  assert(filePtr != NULL);
1154 
1155  assert(ifwrite(filePtr,
1156  IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1157  IFILE_Test::TEST_FILE_CONTENTS.length())
1158  == IFILE_Test::TEST_FILE_CONTENTS.length());
1159 
1160  assert(ifclose(filePtr) == 0);
1161 
1162  filename = "results/uncompressedFile.glf";
1163 
1164  filePtr = ifopen(filename.c_str(), "wt", InputFile::UNCOMPRESSED);
1165  assert(filePtr != NULL);
1166 
1167  assert(ifwrite(filePtr,
1168  IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1169  IFILE_Test::TEST_FILE_CONTENTS.length())
1170  == IFILE_Test::TEST_FILE_CONTENTS.length());
1171 
1172  assert(ifclose(filePtr) == 0);
1173 
1174  filename = "results/bgzfFile.glf";
1175 
1176  filePtr = ifopen(filename.c_str(), "wt", InputFile::BGZF);
1177  assert(filePtr != NULL);
1178 
1179  assert(ifwrite(filePtr,
1180  IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1181  IFILE_Test::TEST_FILE_CONTENTS.length())
1182  == IFILE_Test::TEST_FILE_CONTENTS.length());
1183 
1184  assert(ifclose(filePtr) == 0);
1185 
1186  filename = "results/gzipFile.glf";
1187 
1188  filePtr = ifopen(filename.c_str(), "wt", InputFile::GZIP);
1189  assert(filePtr != NULL);
1190 
1191  assert(ifwrite(filePtr,
1192  IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1193  IFILE_Test::TEST_FILE_CONTENTS.length())
1194  ==IFILE_Test:: TEST_FILE_CONTENTS.length());
1195 
1196  assert(ifclose(filePtr) == 0);
1197 
1198  filename = "results/defaultFile.glf";
1199 
1200  filePtr = ifopen(filename.c_str(), "wt");
1201  assert(filePtr != NULL);
1202 
1203  assert(ifwrite(filePtr,
1204  IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1205  IFILE_Test::TEST_FILE_CONTENTS.length())
1206  == IFILE_Test::TEST_FILE_CONTENTS.length());
1207 
1208  assert(ifclose(filePtr) == 0);
1209 
1210  filename = "results/defaultFile.gz";
1211 
1212  filePtr = ifopen(filename.c_str(), "wt");
1213  assert(filePtr != NULL);
1214 
1215  assert(ifwrite(filePtr,
1216  IFILE_Test::TEST_FILE_CONTENTS.c_str(),
1217  IFILE_Test::TEST_FILE_CONTENTS.length())
1218  == IFILE_Test::TEST_FILE_CONTENTS.length());
1219 
1220  assert(ifclose(filePtr) == 0);
1221 
1222 
1223  filename = "results/textFile.gz";
1224 
1225  unsigned int myuint = 99;
1226  int myint = -99;
1227  char mychar = 'z';
1228 
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);
1242 
1243  filename = "results/textFile1.gz";
1244  InputFile& fileRef = *(ifopen(filename.c_str(), "wt"));
1245  fileRef << "Hello\n";
1246  fileRef << "Hello." << 3 << ' ' << -2 << "How are you";
1247  fileRef << "?" << "\n";
1248  fileRef << mytext;
1249  fileRef << 3.125 << mychar;
1250  fileRef << myuint;
1251  fileRef << mychar;
1252  fileRef << myint;
1253  fileRef << myString;
1254  InputFile* fileRefPtr = &fileRef;
1255  assert(ifclose(fileRefPtr) == 0);
1256  assert(fileRefPtr == NULL);
1257 
1258  // TODO - automatically verify that the files were written in the
1259  // correct format - rather than hand checking.
1260 }
1261 
1262 
1263 
1264 void testAdditional(const char* extension)
1265 {
1266  std::string fileName = "data/InputFileTest2.";
1267  fileName += extension;
1268  IFILE testFile = ifopen(fileName.c_str(), "r");
1269  assert(testFile != NULL);
1270 
1271  std::string buffer = "989";
1272  std::string stopChars = "C5F2";
1273 
1274  // Test readTilChar that stores the string.
1275  assert(testFile->readTilChar(stopChars, buffer) == 0);
1276  assert(buffer == "989AB");
1277  buffer.clear();
1278  assert(testFile->readTilChar(stopChars, buffer) == 2);
1279  assert(buffer == "DE");
1280  assert(testFile->readTilChar(stopChars, buffer) == 3);
1281  assert(buffer == "DEG\tabcdefg\n1");
1282 
1283  // Test readTilChar that discards the string.
1284  assert(testFile->readTilChar(stopChars) == 1);
1285  buffer.clear();
1286  buffer = "t";
1287  assert(testFile->readTilTab(buffer) == 1);
1288  assert(buffer == "t6");
1289  assert(testFile->readTilTab(buffer) == 0);
1290  assert(buffer == "t6hijklm");
1291  assert(testFile->readTilTab(buffer) == 0);
1292  assert(buffer == "t6hijklm1");
1293  assert(testFile->readTilTab(buffer) == 1);
1294  assert(buffer == "t6hijklm1NOP");
1295  assert(testFile->readLine(buffer) == 0);
1296  assert(buffer == "t6hijklm1NOPQRST\tUVW");
1297  assert(testFile->readTilTab(buffer) == 0);
1298  assert(buffer == "t6hijklm1NOPQRST\tUVW");
1299  buffer.clear();
1300  assert(testFile->discardLine() == 0);
1301  assert(testFile->readLine(buffer) == -1);
1302  assert(buffer == "@#$");
1303  assert(testFile->discardLine() == -1);
1304  assert(testFile->readTilTab(buffer) == -1);
1305  assert(testFile->readTilChar(stopChars, buffer) == -1);
1306  assert(testFile->readTilChar(stopChars) == -1);
1307  assert(buffer == "@#$");
1308 
1309  ifclose(testFile);
1310 
1311 }
IFILE ifopen(const char *filename, const char *mode, InputFile::ifileCompression compressionMode=InputFile::DEFAULT)
Open a file with the specified name and mode, using a filename of "-" to indicate stdin/stdout.
Definition: InputFile.h:562
int ifclose(IFILE &file)
Close the file.
Definition: InputFile.h:580
unsigned int ifwrite(IFILE file, const void *buffer, unsigned int size)
Write the specified number of bytes from the specified buffer into the file.
Definition: InputFile.h:669
Class for easily reading/writing files without having to worry about file type (uncompressed,...
Definition: InputFile.h:37
void bufferReads(unsigned int bufferSize=DEFAULT_BUFFER_SIZE)
Set the buffer size for reading from files so that bufferSize bytes are read at a time and stored unt...
Definition: InputFile.h:83
int ifclose()
Close the file.
Definition: InputFile.h:133
int readLine(std::string &line)
Read, appending the characters into the specified string until new line or EOF is found,...
Definition: InputFile.cpp:112
void disableBuffering()
Disable read buffering.
Definition: InputFile.h:121
bool isOpen() const
Returns whether or not the file was successfully opened.
Definition: InputFile.h:423
int ifeof() const
Check to see if we have reached the EOF.
Definition: InputFile.h:386
int ifread(void *buffer, unsigned int size)
Read size bytes from the file into the buffer.
Definition: InputFile.h:153
void ifrewind()
Reset to the beginning of the file.
Definition: InputFile.h:368
int64_t iftell()
Get current position in the file.
Definition: InputFile.h:436
int ifgetc()
Get a character from the file.
Definition: InputFile.h:324
int discardLine()
Read until the end of the line, discarding the characters, returning -1 returned for EOF and returnin...
Definition: InputFile.cpp:95
@ BGZF
bgzf file.
Definition: InputFile.h:48
@ GZIP
gzip file.
Definition: InputFile.h:47
@ DEFAULT
Check the extension, if it is ".gz", treat as gzip, otherwise treat it as UNCOMPRESSED.
Definition: InputFile.h:45
@ UNCOMPRESSED
uncompressed file.
Definition: InputFile.h:46
int readTilTab(std::string &field)
Read, appending the characters into the specified string until tab, new line, or EOF is found,...
Definition: InputFile.cpp:133
bool ifseek(int64_t offset, int origin)
Seek to the specified offset from the origin.
Definition: InputFile.h:457
int readTilChar(const std::string &stopChars, std::string &stringRef)
Read until the specified characters, returning which character was found causing the stop,...
Definition: InputFile.cpp:44