libkern/kxld/tests/kxld_array_test.c

   1 /*
   2  * Copyright (c) 2009 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #include <assert.h>
  29 #include <limits.h>
  30 #include <stdlib.h>
  31 #include <strings.h>
  32
  33 #include <mach/mach_init.h>
  34
  35 #include "kxld_array.h"
  36 #include "kxld_test.h"
  37 #include "kxld_util.h"
  38
  39 #define kNumStorageTestItems (u_int) (4 * PAGE_SIZE / sizeof(u_int))
  40
  41 int
  42 main(int argc __unused, char *argv[] __unused)
  43 {
  44         kern_return_t rval = KERN_FAILURE;
  45         KXLDArray array;
  46         u_int *item = 0;
  47         u_int test_num = 0;
  48         u_int idx = 0;
  49         u_int titems = 0;
  50         u_int storageTestItems[kNumStorageTestItems];
  51         u_int i = 0;
  52
  53         bzero(&array, sizeof(array));
  54
  55         kxld_set_logging_callback(kxld_test_log);
  56         kxld_set_logging_callback_data("kxld_array_test", NULL);
  57
  58         kxld_log(0, 0, "%d: Initialize", ++test_num);
  59
  60         titems = PAGE_SIZE / sizeof(u_int);
  61         rval = kxld_array_init(&array, sizeof(u_int), titems);
  62         assert(rval == KERN_SUCCESS);
  63         assert(array.nitems == titems);
  64
  65         kxld_log(0, 0, "%d: Get item", ++test_num);
  66         idx = 0;
  67         item = kxld_array_get_item(&array, idx);
  68         assert(item);
  69         assert(item == kxld_array_get_slot(&array, idx));
  70
  71         idx = titems - 1;
  72         item = kxld_array_get_item(&array, idx);
  73         assert(item);
  74         assert(item == kxld_array_get_slot(&array, idx));
  75
  76         idx = titems;
  77         item = kxld_array_get_item(&array, idx);
  78         assert(!item);
  79         /* We allocated the max number of items that could be stored in a page,
  80          * so get_slot() and get_item() are equivalent.
  81          */
  82         assert(item == kxld_array_get_slot(&array, idx));
  83
  84         kxld_log(0, 0, "%d: Resize", ++test_num);
  85
  86         titems = 2 * PAGE_SIZE / sizeof(u_int) + 100;
  87         rval = kxld_array_resize(&array, titems);
  88         assert(rval == KERN_SUCCESS);
  89         assert(array.nitems == titems);
  90
  91         kxld_log(0, 0, "%d: Get more items", ++test_num);
  92         idx = 0;
  93         item = kxld_array_get_item(&array, idx);
  94         assert(item);
  95         assert(item == kxld_array_get_slot(&array, idx));
  96
  97         idx = titems - 1;
  98         item = kxld_array_get_item(&array, idx);
  99         assert(item);
 100         assert(item == kxld_array_get_slot(&array, idx));
 101
 102         idx = titems;
 103         item = kxld_array_get_item(&array, idx);
 104         assert(!item);
 105         /* We allocated fewer items than could fit in a page, so get_slot() will
 106          * return items even when get_item() does not.  See below for details.
 107          */
 108         assert(item != kxld_array_get_slot(&array, idx));
 109
 110         kxld_log(0, 0, "%d: Clear and attempt to get an item", ++test_num);
 111         (void) kxld_array_clear(&array);
 112         item = kxld_array_get_item(&array, 0);
 113         assert(!item);
 114
 115         kxld_log(0, 0, "%d: Get slot", ++test_num);
 116         /* The array allocates its internal storage in pages. Because get_slot()
 117          * fetches items based on the allocated size, not the logical size, we
 118          * calculate the max items get_slot() can retrieve based on page size.
 119          */
 120         titems = (u_int) (round_page(titems * sizeof(u_int)) / sizeof(u_int));
 121         assert(!item);
 122         item = kxld_array_get_slot(&array, 0);
 123         assert(item);
 124         item = kxld_array_get_slot(&array, titems - 1);
 125         assert(item);
 126         item = kxld_array_get_slot(&array, titems);
 127         assert(!item);
 128
 129         kxld_log(0, 0, "%d: Reinitialize", ++test_num);
 130
 131         titems = kNumStorageTestItems;
 132         rval = kxld_array_init(&array, sizeof(u_int), titems);
 133         assert(rval == KERN_SUCCESS);
 134         assert(array.nitems == titems);
 135
 136         kxld_log(0, 0, "%d: Storage test - %d insertions and finds",
 137             ++test_num, kNumStorageTestItems);
 138         for (i = 0; i < titems; ++i) {
 139                 item = kxld_array_get_item(&array, i);
 140                 assert(item);
 141
 142                 *item = (u_int) (random() % UINT_MAX);
 143                 storageTestItems[i] = *item;
 144         }
 145
 146         for (i = 0; i < titems; ++i) {
 147                 item = kxld_array_get_item(&array, i);
 148                 assert(item);
 149                 assert(*item == storageTestItems[i]);
 150         }
 151
 152         (void) kxld_array_deinit(&array);
 153
 154         kxld_log(0, 0, " ");
 155         kxld_log(0, 0, "All tests passed!  Now check for memory leaks...");
 156
 157         kxld_print_memory_report();
 158
 159         return 0;
 160 }