source: rtems/testsuites/fstests/fsrfsbitmap01/test.c @ 9c12bcfd

5
Last change on this file since 9c12bcfd was 9c12bcfd, checked in by Sebastian Huber <sebastian.huber@…>, on Jan 7, 2019 at 8:32:16 AM

Fix format warnings

  • Property mode set to 100644
File size: 18.7 KB
Line 
1/*
2 *  Copyright (c) 2012.
3 *  Krzysztof Miesowicz <krzysztof.miesowicz@gmail.com>
4 *
5 *  This test is extended version of rtems-rfs-bimaps-ut.c . Most of this code
6 *  was written by Chris Johns in rtems-rfs-bitmaps-ut.c and is copied
7 *  and pasted here. Rest of this test was written by Krzysztof Miesowicz to
8 *  completely cover rtems_rfs_bitmap_* symbols.
9 *
10 *  The license and distribution terms for this file may be
11 *  found in the file LICENSE in this distribution or at
12 *  http://www.rtems.org/license/LICENSE.
13 */
14
15
16#if HAVE_CONFIG_H
17#include "config.h"
18#endif
19
20#include <stdio.h>
21#include <stdlib.h>
22#include <inttypes.h>
23
24#include <rtems/rfs/rtems-rfs-bitmaps.h>
25#include <rtems/rfs/rtems-rfs-file-system.h>
26
27#include "fstest.h"
28#include "fs_config.h"
29#include "tmacros.h"
30#include <rtems/malloc.h>
31
32const char rtems_test_name[] = "FSRFSBITMAP 1";
33
34#define rtems_rfs_exit_on_error(_rc, _r, _c, _b)                         \
35  if ((_rc > 0) || _r) { free (_b); rtems_rfs_bitmap_close (_c); return; }
36
37static bool
38rtems_rfs_bitmap_ut_test_range (rtems_rfs_bitmap_control* control,
39                                int                       test,
40                                bool                      set,
41                                rtems_rfs_bitmap_bit      bit,
42                                size_t                    size)
43{
44  unsigned int count;
45  bool         result;
46  for (count = 0; count < size; count++)
47  {
48    int rc = rtems_rfs_bitmap_map_test (control, bit + count, &result);
49    if (rc > 0)
50    {
51      printf (" %2d. Test bit %" PRId32 " in range (%" PRId32 ",%zu] is %s: ",
52            test, bit + count, bit, bit + size - 1, !set ? "set" : "clear");
53      printf ("FAIL (%s)\n", strerror (rc));
54      return false;
55    }
56    if (!set)
57      result = !result;
58    if (!result)
59    {
60      printf (" %2d. Test bit %" PRId32 " in range (%" PRId32 ",%zu] is %s: ",
61              test, bit + count, bit, bit + size - 1, !set ? "set" : "clear");
62      printf (" %s\n", !result ? "pass" : "FAIL");
63      return false;
64    }
65  }
66
67  printf (" %2d. Test bit range (%" PRId32 ",%zu] all %s: pass\n",
68          test, bit, bit + size - 1, set ? "set" : "clear");
69
70  return true;
71}
72
73static bool
74rtems_rfs_bitmap_ut_alloc_seq_test (rtems_rfs_bitmap_control* control,
75                                    int                       test,
76                                    rtems_rfs_bitmap_bit      bit,
77                                    size_t                    size)
78{
79  bool state;
80  int  i;
81  int  rc;
82
83  printf (" %2d. Set all bits\n", test);
84  rc = rtems_rfs_bitmap_map_set_all (control);
85  if (rc > 0)
86  {
87    printf (" %2d. set all bits: FAIL (%s)\n", test, strerror (rc));
88    return false;
89  }
90
91  for (i = 0; i < size; i++)
92    rtems_rfs_bitmap_map_clear (control, bit + i);
93
94  printf (" %2d. Cleared bits (%" PRId32 ", %zu] (%zu)\n",
95          test, bit, bit + size - 1, size);
96
97  for (i = 0; i < rtems_rfs_bitmap_element_bits (); i++)
98  {
99    rc = rtems_rfs_bitmap_map_test (control, bit + i, &state);
100    if (rc > 0)
101    {
102      printf (" %2d. test bit: FAIL (%s)\n", test, strerror (rc));
103      return false;
104    }
105    if (state)
106    {
107      printf (" %2d. Cleared bit still set: bit = %" PRId32 "\n", test, bit + i);
108      return false;
109    }
110  }
111
112  for (i = 0, bit = 0; i < size; i++)
113  {
114    rtems_rfs_bitmap_bit seed = bit;
115    bool                 result;
116    int                  rc;
117    rc = rtems_rfs_bitmap_map_alloc (control, seed, &result, &bit);
118    if (rc > 0)
119    {
120      printf (" %2d. map all: FAIL (%s)\n", test, strerror (rc));
121      return false;
122    }
123    if (!result)
124    {
125      printf (" %2d. Find bit with seed = %" PRId32 ": %s: bit = %" PRId32 "\n",
126              test, seed, result ? "pass" : "FAIL", bit);
127      return false;
128    }
129  }
130
131  printf (" %2d. Alloc'ed all bits (%" PRId32 ", %zu] (%zu)\n",
132          test, bit, bit + size - 1, size);
133
134  return true;
135}
136
137static void
138rtems_rfs_bitmap_ut_test_bitmap (size_t size)
139{
140  rtems_rfs_file_system    fs;
141  rtems_rfs_bitmap_control control;
142  rtems_rfs_buffer_handle  handle;
143  rtems_rfs_buffer         buffer;
144  rtems_rfs_bitmap_bit     bit = 0;
145  rtems_rfs_bitmap_bit     first_bit;
146  rtems_rfs_bitmap_bit     last_bit;
147  bool                     result;
148  size_t                   bytes;
149  size_t                   clear;
150  int                      rc;
151
152  bytes = (rtems_rfs_bitmap_elements (size) *
153           sizeof (rtems_rfs_bitmap_element));
154
155  memset (&fs, 0, sizeof (fs));
156  memset (&buffer, 0, sizeof (buffer));
157
158  buffer.buffer = malloc (bytes);
159  buffer.block = 1;
160
161  if (!buffer.buffer)
162  {
163    printf (" Cannot allocate bitmap memory\n");
164    return;
165  }
166
167#if RTEMS_RFS_BITMAP_CLEAR_ZERO
168  memset (buffer.buffer, 0, bytes);
169#else
170  memset (buffer.buffer, 0xff, bytes);
171#endif
172
173  /*
174   * Do not close the handle so no writes need occur.
175   */
176  rc = rtems_rfs_buffer_handle_open (&fs, &handle);
177  if (rc > 0)
178  {
179    printf (" Cannot open the handle: %d: %s\n", rc, strerror (rc));
180    free (buffer.buffer);
181    return;
182  }
183
184  handle.buffer = &buffer;
185  handle.bnum = 1;
186
187  printf ("\nRFS Bitmap Test : size = %zu (%zu)\n",
188          size, rtems_rfs_bitmap_elements (size));
189
190  rc = rtems_rfs_bitmap_open (&control, &fs, &handle, size, 1);
191  if (rc > 0)
192  {
193    printf (" Cannot open the bitmap: %s\n", strerror (rc));
194    free (buffer.buffer);
195    return;
196  }
197
198  /* Check the free and size are equal after opening */
199  rtems_test_assert( control.free == control.size );
200
201  /*
202   * This is a new bitmap with no bits set. Try and find a bit with a few
203   * seeds.
204   */
205  rc = rtems_rfs_bitmap_map_alloc (&control, size * 2, &result, &bit);
206  printf ("  1. Find bit with seed > size: %s (%s)\n",
207          result ? "FAIL" : "pass", strerror (rc));
208  rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
209
210  rc = rtems_rfs_bitmap_map_alloc (&control, size, &result, &bit);
211  printf ("  2. Find bit with seed = size: %s (%s)\n",
212          result ? "FAIL" : "pass", strerror (rc));
213  rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
214
215  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
216  result = result && (bit == 0);
217  printf ("  3. Find bit 0 with seed = 0: %s (%s): bit = %" PRId32 "\n",
218          result ? "pass" : "FAIL", strerror (rc),  bit);
219  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
220
221  rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
222  result = result && (bit == (size - 1));
223  printf ("  4. Find bit (size - 1) with seed = (size - 1) (%zu): %s (%s): bit = %" PRId32 "\n",
224          size - 1, result ? "pass" : "FAIL", strerror (rc), bit);
225  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
226
227  /*
228   * Test the bits allocated to make sure they are set.
229   */
230  rc = rtems_rfs_bitmap_map_test (&control, 0, &result);
231  printf ("  5. Test bit 0: %s (%s)\n",
232          result ? "pass" : "FAIL", strerror (rc));
233  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
234
235  rc = rtems_rfs_bitmap_map_test (&control, size - 1, &result);
236  printf ("  6. Test bit (size - 1) (%zu): %s (%s)\n",
237          size - 1, result ? "pass" : "FAIL", strerror (rc));
238  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
239
240  if (!rtems_rfs_bitmap_ut_test_range (&control, 7, false, 1, size - 2))
241    rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
242
243  /*
244   * Set all bits then clear one and find it.
245   */
246  rc = rtems_rfs_bitmap_map_set_all (&control);
247  printf ("  8. Set all bits: %s (%s)\n",
248          rc == 0 ? "PASS" : "FAIL", strerror (rc));
249  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
250  /* Check the free is 0 */
251  rtems_test_assert( control.free == 0 );
252
253  bit = rand () % size;
254
255  rc = rtems_rfs_bitmap_map_clear (&control, bit);
256  printf ("  9. Clear bit %" PRId32 ": %s (%s)\n",
257          bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
258  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
259  rtems_test_assert( control.free == 1);
260
261  last_bit = bit;
262  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
263  result = result && (bit == last_bit);
264  printf (" 10. Find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
265          result ? "pass" : "FAIL", strerror (rc), bit);
266  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
267
268  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
269  result = !result || (bit != last_bit);
270  printf (" 11. Fail to find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
271          result ? "pass" : "FAIL", strerror (rc), bit);
272  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
273
274  rc = rtems_rfs_bitmap_map_clear (&control, 0);
275  printf (" 12. Clear bit 0: %s (%s)\n",
276          rc == 0 ? "pass" : "FAIL", strerror (rc));
277  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
278  rtems_test_assert( control.free == 1);
279
280  rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
281  result = result && (bit == 0);
282  printf (" 13. Find bit with seed = (size - 1): %s (%s): bit = %" PRId32 "\n",
283          result ? "pass" : "FAIL", strerror (rc), bit);
284  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
285
286  rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
287  printf (" 14. Clear bit (size - 1) (%zu): %s (%s)\n",
288          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
289  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
290
291  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
292  result = result && (bit == (size - 1));
293  printf (" 15. Find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
294          result ? "pass" : "FAIL", strerror (rc), bit);
295  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
296
297  rc = rtems_rfs_bitmap_map_clear (&control, 0);
298  printf (" 16. Clear bit 0: %s (%s)\n",
299          rc == 0 ? "pass" : "FAIL", strerror (rc));
300
301  rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
302  result = result && (bit == 0);
303  printf (" 17. Find bit with seed = (size / 2) (%zu): %s (%s): bit = %" PRId32 "\n",
304          size / 2, result ? "pass" : "FAIL", strerror (rc), bit);
305  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
306
307  rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
308  printf (" 18. Clear bit (size - 1) (%zu): %s, (%s)\n",
309          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
310  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
311
312  rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
313  result = result && (bit == (size - 1));
314  printf (" 19. Find bit with seed = (size / 2) (%zu): %s (%s): bit = %" PRId32 "\n",
315          size / 2, result ? "pass" : "FAIL", strerror (rc), bit);
316  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
317
318  rc = rtems_rfs_bitmap_map_clear (&control, 0);
319  printf (" 20. Clear bit 0: %s (%s)\n",
320          rc == 0 ? "pass" : "FAIL", strerror (rc));
321
322  rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
323  result = result && (bit == 0);
324  printf (" 21. Find bit with seed = ((size / 2) - 1) (%zu): %s (%s): bit = %" PRId32 "\n",
325          (size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
326  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
327
328  rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
329  printf (" 22. Clear bit (size - 1) (%zu): %s (%s)\n",
330          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
331
332  rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
333  result = result && (bit == (size - 1));
334  printf (" 23. Find bit with seed = ((size / 2) - 1) (%zu): %s (%s): bit = %" PRId32 "\n",
335          (size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
336  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
337
338  bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
339  result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 23, bit,
340                                               rtems_rfs_bitmap_element_bits ());
341  rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
342
343  bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
344  result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 24, bit, 57);
345  rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
346
347  /*
348   * Set all bits, clear a random numberone then create a search map and make
349   * sure the clear count is correct.
350   */
351  rc = rtems_rfs_bitmap_map_set_all (&control);
352  printf (" 25. Set all bits: %s (%s)\n",
353          rc == 0 ? "PASS" : "FAIL", strerror (rc));
354  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
355
356  first_bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
357  last_bit = first_bit + rand () % (size / 2) + rtems_rfs_bitmap_element_bits();
358
359  for (bit = first_bit; bit < last_bit; bit++)
360  {
361    rc = rtems_rfs_bitmap_map_clear (&control, bit);
362    if (rc > 0)
363    {
364      printf (" 26. Clear bit %" PRId32 ": %s (%s)\n",
365              bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
366      rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
367    }
368  }
369
370  printf (" 26. Clear bit (%" PRId32 ", %" PRId32 "]: %s (%s)\n",
371          first_bit, last_bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
372
373  clear = rtems_rfs_bitmap_map_free (&control);
374  result = clear == (last_bit - first_bit);
375  printf (" 27. Check free count is %zu: %" PRId32 ": %s (%s)\n",
376          clear, last_bit - first_bit,
377          result ? "pass" : "FAIL", strerror (rc));
378
379  rc = rtems_rfs_bitmap_create_search (&control);
380  result = clear == rtems_rfs_bitmap_map_free (&control);
381  printf (" 28. Create search check free count is %zu: %zu: %s (%s)\n",
382          clear, rtems_rfs_bitmap_map_free (&control),
383          result ? "pass" : "FAIL", strerror (rc));
384  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
385
386  rtems_rfs_bitmap_bit mybit = control.size +2;
387
388  printf (" 29. Map set check with bit (%d) larger than size (%d)\n",
389          (int)mybit, (int)control.size);
390  rc = rtems_rfs_bitmap_map_set(&control, mybit);
391  rtems_test_assert( rc == EINVAL );
392
393  printf (" 30. Map clear check with bit (%d) larger than size (%d)\n",
394          (int)mybit, (int)control.size);
395  rc = rtems_rfs_bitmap_map_clear(&control, mybit);
396  rtems_test_assert( rc == EINVAL );
397
398  printf (" 31. Map test check with bit (%d) larger than size (%d)\n",
399          (int)mybit, (int)control.size);
400  rc = rtems_rfs_bitmap_map_test(&control, mybit ,&result);
401  rtems_test_assert( rc == EINVAL );
402
403  /* Set all bits, clear one and then set this cleared bit once again */
404  printf (" 32. Set all bits in the map, then clear bit (%zu) and set this bit once again:",control.size/2);
405  rc = rtems_rfs_bitmap_map_set_all(&control);
406  rtems_test_assert( rc == 0 );
407  rc = rtems_rfs_bitmap_map_clear(&control, control.size/2);
408  rtems_test_assert (rc == 0 );
409  rc = rtems_rfs_bitmap_map_set(&control, control.size/2);
410  rtems_test_assert (rc == 0 );
411  printf ("  PASSED\n");
412
413  /* Attempt to find free bit (with different seeds) when all bits are set */
414  printf (" 33. Attempt to find bit when all bits are set (expected FAILED):");
415  rc = rtems_rfs_bitmap_map_alloc(&control, 0, &result, &bit);
416  rtems_test_assert(rc == 0 );
417  rtems_test_assert ( result == false );
418  rc = rtems_rfs_bitmap_map_alloc(&control, size-1, &result, &bit);
419  rtems_test_assert(rc == 0 );
420  rtems_test_assert ( result == false );
421  rc = rtems_rfs_bitmap_map_alloc(&control, size/2, &result, &bit);
422  rtems_test_assert(rc == 0 );
423  rtems_test_assert ( result == false );
424  rc = rtems_rfs_bitmap_map_alloc(&control, 1, &result, &bit);
425  rtems_test_assert(rc == 0 );
426  rtems_test_assert ( result == false );
427  rc = rtems_rfs_bitmap_map_alloc(&control, -2, &result, &bit);
428  rtems_test_assert(rc == 0 );
429  rtems_test_assert ( result == false );
430  printf(" FAILED\n");
431
432  /* Simply clear all bits */
433  printf (" 34. Clear all bits in the map.\n");
434  rc = rtems_rfs_bitmap_map_clear_all(&control);
435  rtems_test_assert( rc == 0 );
436  /* Check the free and size are equal after clearing all */
437  rtems_test_assert( control.free == control.size );
438
439  /* Check accounting for bits when setting a bit, see #3089 */
440  printf (" 35. Set a bit and check accounting.\n");
441  rc = rtems_rfs_bitmap_map_set(&control, 0);
442  rtems_test_assert( rc == 0 );
443  rtems_test_assert( control.free == control.size - 1);
444  /* Setting again should not change the accounting. */
445  rc = rtems_rfs_bitmap_map_set(&control, 0);
446  rtems_test_assert( rc == 0 );
447  rtems_test_assert( control.free == control.size - 1);
448
449  rtems_rfs_bitmap_close (&control);
450  free (buffer.buffer);
451}
452
453static void rtems_rfs_bitmap_unit_test (void)
454{
455  printf (" Bit set value       : %d\n", RTEMS_RFS_BITMAP_BIT_SET);
456  printf (" Bit clear value     : %d\n", RTEMS_RFS_BITMAP_BIT_CLEAR);
457  printf (" Num bit per element : %zu\n", rtems_rfs_bitmap_element_bits ());
458
459#if INT_MAX >= 0x23984237
460  srand (0x23984237);
461#else
462  srand (0x2398);
463#endif
464  rtems_rfs_bitmap_ut_test_bitmap (4096);
465  rtems_rfs_bitmap_ut_test_bitmap (2048);
466  rtems_rfs_bitmap_ut_test_bitmap (420);
467}
468
469static void nullpointer_test(void){
470
471  rtems_rfs_bitmap_control control;
472  rtems_rfs_bitmap_bit  bit = 0;
473  rtems_rfs_bitmap_bit  seed_bit = 0;
474  int rc;
475  bool result;
476
477  memset(&control, 0, sizeof(control));
478
479  printf ("\n Testing bitmap_map functions with zero "
480            "initialized bitmap control pointer\n");
481
482  /* Invoke all functions with control initialized to zero */
483  rc = rtems_rfs_bitmap_map_set(&control, bit);
484  rtems_test_assert(rc == ENXIO);
485  rc = rtems_rfs_bitmap_map_clear(&control, bit);
486  rtems_test_assert(rc == ENXIO);
487  rc = rtems_rfs_bitmap_map_test(&control, bit, &result);
488  rtems_test_assert(rc == ENXIO);
489  rc = rtems_rfs_bitmap_map_set_all(&control);
490  rtems_test_assert(rc == ENXIO);
491  rc = rtems_rfs_bitmap_map_clear_all(&control);
492  rtems_test_assert(rc == ENXIO);
493  rc = rtems_rfs_bitmap_create_search(&control);
494  rtems_test_assert(rc == ENXIO);
495  rc = rtems_rfs_bitmap_map_alloc(&control, seed_bit, &result, &bit);
496  rtems_test_assert(rc == 0);
497  rtems_test_assert(!result);
498  rc = rtems_rfs_bitmap_map_set(&control, bit);
499  rtems_test_assert(rc == ENXIO);
500}
501
502static void open_failure(void){
503
504  rtems_rfs_file_system     fs;
505  rtems_rfs_bitmap_control  control;
506  rtems_rfs_buffer_handle   handle;
507  int                       rc;
508  void                     *opaque;
509
510  /* Attempt to get ENOMEM while open bitmap */
511  printf("\n Allocate most of memory - attempt to fail while open bitmap - expect ENOMEM\n" );
512
513  opaque = rtems_heap_greedy_allocate( NULL, 0 );
514
515  memset (&fs, 0, sizeof (fs));
516
517  rc = rtems_rfs_buffer_handle_open (&fs, &handle);
518  rtems_test_assert( rc == 0 );
519
520  rc = rtems_rfs_bitmap_open (&control, &fs, &handle, 0, 0);
521  rtems_test_assert( rc == ENOMEM );
522  printf( " Attempt to open bitmap returned: %s\n", strerror(rc));
523  puts( " Freeing the allocated memory" );
524  rtems_heap_greedy_free( opaque );
525}
526
527void test(void){
528  puts("\n START of RFS Bitmap Unit Test");
529
530  rtems_rfs_bitmap_unit_test();
531  nullpointer_test();
532  open_failure();
533
534  puts("\n END of RFS Bitmap Unit Test");
535}
Note: See TracBrowser for help on using the repository browser.