source: rtems/testsuites/fstests/fsrfsbitmap01/test.c @ 29b1bbf

4.11
Last change on this file since 29b1bbf was 29b1bbf, checked in by Joel Sherrill <joel.sherrill@…>, on Sep 28, 2012 at 7:07:24 PM

fsrfsbitmap01/test.c: Remove tabs

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