source: rtems/testsuites/fstests/fsrfsbitmap01/test.c @ bc75887

4.11
Last change on this file since bc75887 was bc75887, checked in by Sebastian Huber <sebastian.huber@…>, on Mar 16, 2014 at 3:15:33 PM

tests/fstests: Use <rtems/test.h>

  • Property mode set to 100644
File size: 17.9 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.com/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 ",%ld] 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 ",%ld] 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 ",%ld] 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 ", %ld] (%zd)\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 ", %ld] (%zd)\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 = %zd (%zd)\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  /*
199   * This is a new bitmap with no bits set. Try and find a bit with a few
200   * seeds.
201   */
202  rc = rtems_rfs_bitmap_map_alloc (&control, size * 2, &result, &bit);
203  printf ("  1. Find bit with seed > size: %s (%s)\n",
204          result ? "FAIL" : "pass", strerror (rc));
205  rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
206
207  rc = rtems_rfs_bitmap_map_alloc (&control, size, &result, &bit);
208  printf ("  2. Find bit with seed = size: %s (%s)\n",
209          result ? "FAIL" : "pass", strerror (rc));
210  rtems_rfs_exit_on_error (rc, result, &control, buffer.buffer);
211
212  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
213  result = result && (bit == 0);
214  printf ("  3. Find bit 0 with seed = 0: %s (%s): bit = %" PRId32 "\n",
215          result ? "pass" : "FAIL", strerror (rc),  bit);
216  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
217
218  rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
219  result = result && (bit == (size - 1));
220  printf ("  4. Find bit (size - 1) with seed = (size - 1) (%zd): %s (%s): bit = %" PRId32 "\n",
221          size - 1, result ? "pass" : "FAIL", strerror (rc), bit);
222  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
223
224  /*
225   * Test the bits allocated to make sure they are set.
226   */
227  rc = rtems_rfs_bitmap_map_test (&control, 0, &result);
228  printf ("  5. Test bit 0: %s (%s)\n",
229          result ? "pass" : "FAIL", strerror (rc));
230  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
231
232  rc = rtems_rfs_bitmap_map_test (&control, size - 1, &result);
233  printf ("  6. Test bit (size - 1) (%zd): %s (%s)\n",
234          size - 1, result ? "pass" : "FAIL", strerror (rc));
235  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
236
237  if (!rtems_rfs_bitmap_ut_test_range (&control, 7, false, 1, size - 2))
238    rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
239
240  /*
241   * Set all bits then clear one and find it.
242   */
243  rc = rtems_rfs_bitmap_map_set_all (&control);
244  printf ("  8. Set all bits: %s (%s)\n",
245          rc == 0 ? "PASS" : "FAIL", strerror (rc));
246  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
247
248  bit = rand () % size;
249
250  rc = rtems_rfs_bitmap_map_clear (&control, bit);
251  printf ("  9. Clear bit %" PRId32 ": %s (%s)\n",
252          bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
253  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
254
255  last_bit = bit;
256  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
257  result = result && (bit == last_bit);
258  printf (" 10. Find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
259          result ? "pass" : "FAIL", strerror (rc), bit);
260  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
261
262  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
263  result = !result || (bit != last_bit);
264  printf (" 11. Fail to 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_clear (&control, 0);
269  printf (" 12. Clear bit 0: %s (%s)\n",
270          rc == 0 ? "pass" : "FAIL", strerror (rc));
271  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
272
273  rc = rtems_rfs_bitmap_map_alloc (&control, size - 1, &result, &bit);
274  result = result && (bit == 0);
275  printf (" 13. Find bit with seed = (size - 1): %s (%s): bit = %" PRId32 "\n",
276          result ? "pass" : "FAIL", strerror (rc), bit);
277  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
278
279  rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
280  printf (" 14. Clear bit (size - 1) (%zd): %s (%s)\n",
281          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
282  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
283
284  rc = rtems_rfs_bitmap_map_alloc (&control, 0, &result, &bit);
285  result = result && (bit == (size - 1));
286  printf (" 15. Find bit with seed = 0: %s (%s): bit = %" PRId32 "\n",
287          result ? "pass" : "FAIL", strerror (rc), bit);
288  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
289
290  rc = rtems_rfs_bitmap_map_clear (&control, 0);
291  printf (" 16. Clear bit 0: %s (%s)\n",
292          rc == 0 ? "pass" : "FAIL", strerror (rc));
293
294  rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
295  result = result && (bit == 0);
296  printf (" 17. Find bit with seed = (size / 2) (%zd): %s (%s): bit = %" PRId32 "\n",
297          size / 2, result ? "pass" : "FAIL", strerror (rc), bit);
298  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
299
300  rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
301  printf (" 18. Clear bit (size - 1) (%zd): %s, (%s)\n",
302          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
303  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
304
305  rc = rtems_rfs_bitmap_map_alloc (&control, size / 2, &result, &bit);
306  result = result && (bit == (size - 1));
307  printf (" 19. Find bit with seed = (size / 2) (%zd): %s (%s): bit = %" PRId32 "\n",
308          size / 2, result ? "pass" : "FAIL", strerror (rc), bit);
309  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
310
311  rc = rtems_rfs_bitmap_map_clear (&control, 0);
312  printf (" 20. Clear bit 0: %s (%s)\n",
313          rc == 0 ? "pass" : "FAIL", strerror (rc));
314
315  rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
316  result = result && (bit == 0);
317  printf (" 21. Find bit with seed = ((size / 2) - 1) (%zd): %s (%s): bit = %" PRId32 "\n",
318          (size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
319  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
320
321  rc = rtems_rfs_bitmap_map_clear (&control, size - 1);
322  printf (" 22. Clear bit (size - 1) (%zd): %s (%s)\n",
323          size - 1, rc == 0 ? "pass" : "FAIL", strerror (rc));
324
325  rc = rtems_rfs_bitmap_map_alloc (&control, (size / 2) - 1, &result, &bit);
326  result = result && (bit == (size - 1));
327  printf (" 23. Find bit with seed = ((size / 2) - 1) (%zd): %s (%s): bit = %" PRId32 "\n",
328          (size / 2) - 1, result ? "pass" : "FAIL", strerror (rc), bit);
329  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
330
331  bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
332  result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 23, bit,
333                                               rtems_rfs_bitmap_element_bits ());
334  rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
335
336  bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
337  result = rtems_rfs_bitmap_ut_alloc_seq_test (&control, 24, bit, 57);
338  rtems_rfs_exit_on_error (0, !result, &control, buffer.buffer);
339
340  /*
341   * Set all bits, clear a random numberone then create a search map and make
342   * sure the clear count is correct.
343   */
344  rc = rtems_rfs_bitmap_map_set_all (&control);
345  printf (" 25. Set all bits: %s (%s)\n",
346          rc == 0 ? "PASS" : "FAIL", strerror (rc));
347  rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
348
349  first_bit = rand () % (size / 2) + rtems_rfs_bitmap_element_bits ();
350  last_bit = first_bit + rand () % (size / 2) + rtems_rfs_bitmap_element_bits();
351
352  for (bit = first_bit; bit < last_bit; bit++)
353  {
354    rc = rtems_rfs_bitmap_map_clear (&control, bit);
355    if (rc > 0)
356    {
357      printf (" 26. Clear bit %" PRId32 ": %s (%s)\n",
358              bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
359      rtems_rfs_exit_on_error (rc, false, &control, buffer.buffer);
360    }
361  }
362
363  printf (" 26. Clear bit (%" PRId32 ", %" PRId32 "]: %s (%s)\n",
364          first_bit, last_bit, rc == 0 ? "PASS" : "FAIL", strerror (rc));
365
366  clear = rtems_rfs_bitmap_map_free (&control);
367  result = clear == (last_bit - first_bit);
368  printf (" 27. Check free count is %zd: %" PRId32 ": %s (%s)\n",
369          clear, last_bit - first_bit,
370          result ? "pass" : "FAIL", strerror (rc));
371
372  rc = rtems_rfs_bitmap_create_search (&control);
373  result = clear == rtems_rfs_bitmap_map_free (&control);
374  printf (" 28. Create search check free count is %zd: %zd: %s (%s)\n",
375          clear, rtems_rfs_bitmap_map_free (&control),
376          result ? "pass" : "FAIL", strerror (rc));
377  rtems_rfs_exit_on_error (rc, !result, &control, buffer.buffer);
378
379  rtems_rfs_bitmap_bit mybit = control.size +2;
380
381  printf (" 29. Map set check with bit (%d) larger than size (%d)\n",
382          (int)mybit, (int)control.size);
383  rc = rtems_rfs_bitmap_map_set(&control, mybit);
384  rtems_test_assert( rc == EINVAL );
385
386  printf (" 30. Map clear check with bit (%d) larger than size (%d)\n",
387          (int)mybit, (int)control.size);
388  rc = rtems_rfs_bitmap_map_clear(&control, mybit);
389  rtems_test_assert( rc == EINVAL );
390
391  printf (" 31. Map test check with bit (%d) larger than size (%d)\n",
392          (int)mybit, (int)control.size);
393  rc = rtems_rfs_bitmap_map_test(&control, mybit ,&result);
394  rtems_test_assert( rc == EINVAL );
395
396  /* Set all bits, clear one and then set this cleared bit once again */
397  printf (" 32. Set all bits in the map, then clear bit (%zu) and set this bit once again:",control.size/2);
398  rc = rtems_rfs_bitmap_map_set_all(&control);
399  rtems_test_assert( rc == 0 );
400  rc = rtems_rfs_bitmap_map_clear(&control, control.size/2);
401  rtems_test_assert (rc == 0 );
402  rc = rtems_rfs_bitmap_map_set(&control, control.size/2);
403  rtems_test_assert (rc == 0 );
404  printf ("  PASSED\n");
405
406  /* Attempt to find free bit (with different seeds) when all bits are set */
407  printf (" 33. Attempt to find bit when all bits are set (expected FAILED):");
408  rc = rtems_rfs_bitmap_map_alloc(&control, 0, &result, &bit);
409  rtems_test_assert(rc == 0 );
410  rtems_test_assert ( result == false );
411  rc = rtems_rfs_bitmap_map_alloc(&control, size-1, &result, &bit);
412  rtems_test_assert(rc == 0 );
413  rtems_test_assert ( result == false );
414  rc = rtems_rfs_bitmap_map_alloc(&control, size/2, &result, &bit);
415  rtems_test_assert(rc == 0 );
416  rtems_test_assert ( result == false );
417  rc = rtems_rfs_bitmap_map_alloc(&control, 1, &result, &bit);
418  rtems_test_assert(rc == 0 );
419  rtems_test_assert ( result == false );
420  rc = rtems_rfs_bitmap_map_alloc(&control, -2, &result, &bit);
421  rtems_test_assert(rc == 0 );
422  rtems_test_assert ( result == false );
423  printf(" FAILED\n");
424
425  /* Simply clear all bits */
426  printf (" 34. Clear all bits in the map.\n");
427  rc = rtems_rfs_bitmap_map_clear_all(&control);
428  rtems_test_assert( rc == 0 );
429
430  rtems_rfs_bitmap_close (&control);
431  free (buffer.buffer);
432}
433
434static void rtems_rfs_bitmap_unit_test (void)
435{
436  printf (" Bit set value       : %d\n", RTEMS_RFS_BITMAP_BIT_SET);
437  printf (" Bit clear value     : %d\n", RTEMS_RFS_BITMAP_BIT_CLEAR);
438  printf (" Num bit per element : %zd\n", rtems_rfs_bitmap_element_bits ());
439
440#if INT_MAX >= 0x23984237
441  srand (0x23984237);
442#else
443  srand (0x2398);
444#endif
445  rtems_rfs_bitmap_ut_test_bitmap (4096);
446  rtems_rfs_bitmap_ut_test_bitmap (2048);
447  rtems_rfs_bitmap_ut_test_bitmap (420);
448}
449
450static void nullpointer_test(void){
451
452  rtems_rfs_bitmap_control control;
453  rtems_rfs_bitmap_bit  bit = 0;
454  rtems_rfs_bitmap_bit  seed_bit = 0;
455  int rc;
456  bool result;
457
458  memset(&control, 0, sizeof(control));
459
460  printf ("\n Testing bitmap_map functions with zero "
461            "initialized bitmap control pointer\n");
462
463  /* Invoke all functions with control initialized to zero */
464  rc = rtems_rfs_bitmap_map_set(&control, bit);
465  rtems_test_assert(rc == ENXIO);
466  rc = rtems_rfs_bitmap_map_clear(&control, bit);
467  rtems_test_assert(rc == ENXIO);
468  rc = rtems_rfs_bitmap_map_test(&control, bit, &result);
469  rtems_test_assert(rc == ENXIO);
470  rc = rtems_rfs_bitmap_map_set_all(&control);
471  rtems_test_assert(rc == ENXIO);
472  rc = rtems_rfs_bitmap_map_clear_all(&control);
473  rtems_test_assert(rc == ENXIO);
474  rc = rtems_rfs_bitmap_create_search(&control);
475  rtems_test_assert(rc == ENXIO);
476  rc = rtems_rfs_bitmap_map_alloc(&control, seed_bit, &result, &bit);
477  rtems_test_assert(rc == 0);
478  rtems_test_assert(!result);
479  rc = rtems_rfs_bitmap_map_set(&control, bit);
480  rtems_test_assert(rc == ENXIO);
481}
482
483static void open_failure(void){
484
485  rtems_rfs_file_system     fs;
486  rtems_rfs_bitmap_control  control;
487  rtems_rfs_buffer_handle   handle;
488  int                       rc;
489  void                     *opaque;
490
491  /* Attempt to get ENOMEM while open bitmap */
492  printf("\n Allocate most of memory - attempt to fail while open bitmap - expect ENOMEM\n" );
493
494  opaque = rtems_heap_greedy_allocate( NULL, 0 );
495
496  memset (&fs, 0, sizeof (fs));
497
498  rc = rtems_rfs_buffer_handle_open (&fs, &handle);
499  rtems_test_assert( rc == 0 );
500
501  rc = rtems_rfs_bitmap_open (&control, &fs, &handle, 0, 0);
502  rtems_test_assert( rc == ENOMEM );
503  printf( " Attempt to open bitmap returned: %s\n", strerror(rc));
504  puts( " Freeing the allocated memory" );
505  rtems_heap_greedy_free( opaque );
506}
507
508void test(void){
509  puts("\n START of RFS Bitmap Unit Test");
510
511  rtems_rfs_bitmap_unit_test();
512  nullpointer_test();
513  open_failure();
514
515  puts("\n END of RFS Bitmap Unit Test");
516}
Note: See TracBrowser for help on using the repository browser.