xnu-7195.101.1.tar.gz

[apple/xnu.git] / osfmk / tests / bitmap_test.c

diff --git a/osfmk/tests/bitmap_test.c b/osfmk/tests/bitmap_test.c
index 121d92ea1ba79b3179f3282409f4900ea3521f7e..074e0a67f00c73c13246a49936f2ec437738d475 100644 (file)
--- a/osfmk/tests/bitmap_test.c
+++ b/osfmk/tests/bitmap_test.c
@@ -2,7 +2,7 @@
  * Copyright (c) 2015 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
+ *
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
@@ -11,10 +11,10 @@
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.
- * 
+ *
  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
+ *
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
@@ -22,7 +22,7 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
- * 
+ *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 
@@ -32,6 +32,7 @@
 #include <tests/xnupost.h>
 #include <kern/kalloc.h>
 #include <kern/bits.h>
+#include <pexpert/pexpert.h>
 
 extern void dump_bitmap_next(bitmap_t *map, uint nbits);
 extern void dump_bitmap_lsb(bitmap_t *map, uint nbits);
@@ -60,7 +61,7 @@ dump_bitmap_lsb(bitmap_t *map, uint nbits)
 #ifdef assert
 #undef assert
 #endif
-#define assert(x)      T_ASSERT(x, NULL)
+#define assert(x)       T_ASSERT(x, NULL)
 #endif
 
 void
@@ -73,6 +74,7 @@ test_bitmap(void)
                for (uint i = 0; i < nbits; i++) {
                        bitmap_set(map, i);
                }
+               assert(bitmap_is_full(map, nbits));
 
                int expected_result = nbits - 1;
                for (int i = bitmap_first(map, nbits); i >= 0; i = bitmap_next(map, i)) {
@@ -81,6 +83,21 @@ test_bitmap(void)
                }
                assert(expected_result == -1);
 
+               bitmap_zero(map, nbits);
+
+               assert(bitmap_first(map, nbits) == -1);
+               assert(bitmap_lsb_first(map, nbits) == -1);
+
+               bitmap_full(map, nbits);
+               assert(bitmap_is_full(map, nbits));
+
+               expected_result = nbits - 1;
+               for (int i = bitmap_first(map, nbits); i >= 0; i = bitmap_next(map, i)) {
+                       assert(i == expected_result);
+                       expected_result--;
+               }
+               assert(expected_result == -1);
+
                expected_result = 0;
                for (int i = bitmap_lsb_first(map, nbits); i >= 0; i = bitmap_lsb_next(map, nbits, i)) {
                        assert(i == expected_result);
@@ -88,13 +105,70 @@ test_bitmap(void)
                }
                assert(expected_result == (int)nbits);
 
+               for (uint i = 0; i < nbits; i++) {
+                       bitmap_clear(map, i);
+                       assert(!bitmap_is_full(map, nbits));
+                       bitmap_set(map, i);
+                       assert(bitmap_is_full(map, nbits));
+               }
+
                for (uint i = 0; i < nbits; i++) {
                        bitmap_clear(map, i);
                }
                assert(bitmap_first(map, nbits) == -1);
                assert(bitmap_lsb_first(map, nbits) == -1);
 
+               /* bitmap_not */
+               bitmap_not(map, map, nbits);
+               assert(bitmap_is_full(map, nbits));
+
+               bitmap_not(map, map, nbits);
+               assert(bitmap_first(map, nbits) == -1);
+               assert(bitmap_lsb_first(map, nbits) == -1);
+
+               /* bitmap_and */
+               bitmap_t *map0 = bitmap_alloc(nbits);
+               assert(bitmap_first(map0, nbits) == -1);
+
+               bitmap_t *map1 = bitmap_alloc(nbits);
+               bitmap_full(map1, nbits);
+               assert(bitmap_is_full(map1, nbits));
+
+               bitmap_and(map, map0, map1, nbits);
+               assert(bitmap_first(map, nbits) == -1);
+
+               bitmap_and(map, map1, map1, nbits);
+               assert(bitmap_is_full(map, nbits));
+
+               /* bitmap_and_not */
+               bitmap_and_not(map, map0, map1, nbits);
+               assert(bitmap_first(map, nbits) == -1);
+
+               bitmap_and_not(map, map1, map0, nbits);
+               assert(bitmap_is_full(map, nbits));
+
+               /* bitmap_equal */
+               for (uint i = 0; i < nbits; i++) {
+                       bitmap_clear(map, i);
+                       assert(!bitmap_equal(map, map1, nbits));
+                       bitmap_set(map, i);
+                       assert(bitmap_equal(map, map1, nbits));
+               }
+
+               /* bitmap_and_not_mask_first */
+               for (uint i = 0; i < nbits; i++) {
+                       bitmap_clear(map, i);
+                       expected_result = i;
+                       int result = bitmap_and_not_mask_first(map1, map, nbits);
+                       assert(result == expected_result);
+                       bitmap_set(map, i);
+                       result = bitmap_and_not_mask_first(map1, map, nbits);
+                       assert(result == -1);
+               }
+
                bitmap_free(map, nbits);
+               bitmap_free(map0, nbits);
+               bitmap_free(map1, nbits);
        }
 }