22 	ASSERT_NE(memblock.reserved.regions, NULL);  in memblock_initialization_check()
23 	ASSERT_EQ(memblock.reserved.cnt, 0);  in memblock_initialization_check()
25 	ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);  in memblock_initialization_check()
485 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_add_many_check()
486 	ASSERT_EQ(memblock.reserved.total_size, new_memory_regions_size);  in memblock_add_many_check()
542  * and size as reserved and to the collection of reserved memory regions
543  * (memblock.reserved). Expect to create a new entry. The region counter
550 	rgn =  &memblock.reserved.regions[0];  in memblock_reserve_simple_check()
571  * A test that tries to mark two memory blocks that don't overlap as reserved:
577  * Expect to add two entries to the collection of reserved memory regions
578  * (memblock.reserved). The total size and region counter for
579  * memblock.reserved are updated.
585 	rgn1 = &memblock.reserved.regions[0];  in memblock_reserve_disjoint_check()
586 	rgn2 = &memblock.reserved.regions[1];  in memblock_reserve_disjoint_check()
609 	ASSERT_EQ(memblock.reserved.cnt, 2);  in memblock_reserve_disjoint_check()
610 	ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);  in memblock_reserve_disjoint_check()
618  * A test that tries to mark two memory blocks r1 and r2 as reserved,
633  * reserved memory is updated, and the region counter is not updated.
640 	rgn = &memblock.reserved.regions[0];  in memblock_reserve_overlap_top_check()
662 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_reserve_overlap_top_check()
663 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_reserve_overlap_top_check()
671  * A test that tries to mark two memory blocks r1 and r2 as reserved,
686  * reserved memory is updated, and the region counter is not updated.
693 	rgn = &memblock.reserved.regions[0];  in memblock_reserve_overlap_bottom_check()
715 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_reserve_overlap_bottom_check()
716 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_reserve_overlap_bottom_check()
724  * A test that tries to mark two memory blocks r1 and r2 as reserved,
744 	rgn = &memblock.reserved.regions[0];  in memblock_reserve_within_check()
764 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_reserve_within_check()
765 	ASSERT_EQ(memblock.reserved.total_size, r1.size);  in memblock_reserve_within_check()
774  * Expect the region counter and total size of reserved memory to not
791 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_reserve_twice_check()
792 	ASSERT_EQ(memblock.reserved.total_size, r.size);  in memblock_reserve_twice_check()
800  * A test that tries to mark two memory blocks that don't overlap as reserved
807  * Expect to merge the three entries into one reserved region that starts at
809  * total for memblock.reserved are updated.
816 	rgn = &memblock.reserved.regions[0];  in memblock_reserve_between_check()
843 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_reserve_between_check()
844 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_reserve_between_check()
863  * total size of reserved memory and the counter to be updated.
870 	rgn = &memblock.reserved.regions[0];  in memblock_reserve_near_max_check()
887 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_reserve_near_max_check()
888 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_reserve_near_max_check()
899  * reserved.regions.
925 		ASSERT_EQ(memblock.reserved.cnt, i + 1);  in memblock_reserve_many_check()
926 		ASSERT_EQ(memblock.reserved.total_size, (i + 1) * MEM_SIZE);  in memblock_reserve_many_check()
932 	orig_region = memblock.reserved.regions;  in memblock_reserve_many_check()
938 	 * This is the memory region size used by the doubled reserved.regions,  in memblock_reserve_many_check()
939 	 * and it has been reserved due to it has been used. The size is used to  in memblock_reserve_many_check()
940 	 * calculate the total_size that the memblock.reserved have now.  in memblock_reserve_many_check()
946 	 * reserved.regions, and the used memory region will be reserved, so  in memblock_reserve_many_check()
947 	 * there will be one more region exist in the reserved memblock. And the  in memblock_reserve_many_check()
948 	 * one more reserved region's size is new_reserved_regions_size.  in memblock_reserve_many_check()
950 	ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2);  in memblock_reserve_many_check()
951 	ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +  in memblock_reserve_many_check()
953 	ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);  in memblock_reserve_many_check()
960 	ASSERT_EQ(memblock.reserved.regions[0].base, r.base);  in memblock_reserve_many_check()
961 	ASSERT_EQ(memblock.reserved.regions[0].size, r.size);  in memblock_reserve_many_check()
963 	ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3);  in memblock_reserve_many_check()
964 	ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +  in memblock_reserve_many_check()
967 	ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);  in memblock_reserve_many_check()
972 	 * The current reserved.regions is occupying a range of memory that  in memblock_reserve_many_check()
977 	memblock.reserved.regions = orig_region;  in memblock_reserve_many_check()
978 	memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS;  in memblock_reserve_many_check()
989  * memblock.memory.max, find a new valid memory as reserved.regions.
1029 				ASSERT_EQ(memblock.reserved.cnt, i + 1);  in memblock_reserve_all_locations_check()
1030 				ASSERT_EQ(memblock.reserved.total_size, (i + 1) * MEM_SIZE);  in memblock_reserve_all_locations_check()
1032 				ASSERT_EQ(memblock.reserved.cnt, i);  in memblock_reserve_all_locations_check()
1033 				ASSERT_EQ(memblock.reserved.total_size, i * MEM_SIZE);  in memblock_reserve_all_locations_check()
1037 		orig_region = memblock.reserved.regions;  in memblock_reserve_all_locations_check()
1043 		 * This is the memory region size used by the doubled reserved.regions,  in memblock_reserve_all_locations_check()
1044 		 * and it has been reserved due to it has been used. The size is used to  in memblock_reserve_all_locations_check()
1045 		 * calculate the total_size that the memblock.reserved have now.  in memblock_reserve_all_locations_check()
1051 		 * reserved.regions, and the used memory region will be reserved, so  in memblock_reserve_all_locations_check()
1052 		 * there will be one more region exist in the reserved memblock. And the  in memblock_reserve_all_locations_check()
1053 		 * one more reserved region's size is new_reserved_regions_size.  in memblock_reserve_all_locations_check()
1055 		ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2);  in memblock_reserve_all_locations_check()
1056 		ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +  in memblock_reserve_all_locations_check()
1058 		ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);  in memblock_reserve_all_locations_check()
1065 		ASSERT_EQ(memblock.reserved.regions[0].base, r.base);  in memblock_reserve_all_locations_check()
1066 		ASSERT_EQ(memblock.reserved.regions[0].size, r.size);  in memblock_reserve_all_locations_check()
1068 		ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3);  in memblock_reserve_all_locations_check()
1069 		ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +  in memblock_reserve_all_locations_check()
1072 		ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);  in memblock_reserve_all_locations_check()
1077 		 * The current reserved.regions is occupying a range of memory that  in memblock_reserve_all_locations_check()
1082 		memblock.reserved.regions = orig_region;  in memblock_reserve_all_locations_check()
1083 		memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS;  in memblock_reserve_all_locations_check()
1094  * memblock.memory.max, find a new valid memory as reserved.regions. And make
1097  * For example, we have 128 regions in reserved and now want to reserve
1098  * the skipped one. Since reserved is full, memblock_double_array() would find
1102  * reserved array"), the new array would sits in the skipped range which is a
1112  * reserved                  +-------+       .........         +-------+
1140 	 * memblock.reserved.regions at idx 0.  in memblock_reserve_many_may_conflict_check()
1157 		 * Add a memory region which will be reserved as 129th memory  in memblock_reserve_many_may_conflict_check()
1170 				ASSERT_EQ(memblock.reserved.cnt, i);  in memblock_reserve_many_may_conflict_check()
1171 				ASSERT_EQ(memblock.reserved.total_size, i * MEM_SIZE);  in memblock_reserve_many_may_conflict_check()
1173 				ASSERT_EQ(memblock.reserved.cnt, i - 1);  in memblock_reserve_many_may_conflict_check()
1174 				ASSERT_EQ(memblock.reserved.total_size, (i - 1) * MEM_SIZE);  in memblock_reserve_many_may_conflict_check()
1178 		orig_region = memblock.reserved.regions;  in memblock_reserve_many_may_conflict_check()
1184 		 * This is the memory region size used by the doubled reserved.regions,  in memblock_reserve_many_may_conflict_check()
1185 		 * and it has been reserved due to it has been used. The size is used to  in memblock_reserve_many_may_conflict_check()
1186 		 * calculate the total_size that the memblock.reserved have now.  in memblock_reserve_many_may_conflict_check()
1192 		 * reserved.regions, and the used memory region will be reserved, so  in memblock_reserve_many_may_conflict_check()
1193 		 * there will be one more region exist in the reserved memblock. And the  in memblock_reserve_many_may_conflict_check()
1194 		 * one more reserved region's size is new_reserved_regions_size.  in memblock_reserve_many_may_conflict_check()
1196 		ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2);  in memblock_reserve_many_may_conflict_check()
1197 		ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +  in memblock_reserve_many_may_conflict_check()
1199 		ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);  in memblock_reserve_many_may_conflict_check()
1202 		 * The first reserved region is allocated for double array  in memblock_reserve_many_may_conflict_check()
1206 		ASSERT_EQ(memblock.reserved.regions[0].base + memblock.reserved.regions[0].size,  in memblock_reserve_many_may_conflict_check()
1208 		ASSERT_EQ(memblock.reserved.regions[0].size, new_reserved_regions_size);  in memblock_reserve_many_may_conflict_check()
1215 		ASSERT_EQ(memblock.reserved.regions[0].base, r.base);  in memblock_reserve_many_may_conflict_check()
1216 		ASSERT_EQ(memblock.reserved.regions[0].size, r.size);  in memblock_reserve_many_may_conflict_check()
1218 		ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3);  in memblock_reserve_many_may_conflict_check()
1219 		ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE +  in memblock_reserve_many_may_conflict_check()
1222 		ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);  in memblock_reserve_many_may_conflict_check()
1225 		 * The current reserved.regions is occupying a range of memory that  in memblock_reserve_many_may_conflict_check()
1230 		memblock.reserved.regions = orig_region;  in memblock_reserve_many_may_conflict_check()
1231 		memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS;  in memblock_reserve_many_may_conflict_check()
1700  * earlier as reserved. By "freeing" a region we mean overwriting it with
1701  * the next entry r2 in memblock.reserved:
1717 	rgn = &memblock.reserved.regions[0];  in memblock_free_simple_check()
1738 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_free_simple_check()
1739 	ASSERT_EQ(memblock.reserved.total_size, r2.size);  in memblock_free_simple_check()
1747  * A test that tries to free a region r2 that was not marked as reserved
1748  * (i.e. has no corresponding entry in memblock.reserved):
1766 	rgn = &memblock.reserved.regions[0];  in memblock_free_absent_check()
1786 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_free_absent_check()
1787 	ASSERT_EQ(memblock.reserved.total_size, r1.size);  in memblock_free_absent_check()
1818 	rgn = &memblock.reserved.regions[0];  in memblock_free_overlap_top_check()
1840 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_free_overlap_top_check()
1841 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_free_overlap_top_check()
1867 	rgn = &memblock.reserved.regions[0];  in memblock_free_overlap_bottom_check()
1889 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_free_overlap_bottom_check()
1890 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_free_overlap_bottom_check()
1921 	rgn1 = &memblock.reserved.regions[0];  in memblock_free_within_check()
1922 	rgn2 = &memblock.reserved.regions[1];  in memblock_free_within_check()
1949 	ASSERT_EQ(memblock.reserved.cnt, 2);  in memblock_free_within_check()
1950 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_free_within_check()
1959  * earlier as reserved when r1 is the only available region.
1968 	rgn = &memblock.reserved.regions[0];  in memblock_free_only_region_check()
1984 	ASSERT_EQ(memblock.reserved.cnt, 0);  in memblock_free_only_region_check()
1985 	ASSERT_EQ(memblock.reserved.total_size, 0);  in memblock_free_only_region_check()
2003  * Expect the total size of reserved memory to be updated and the counter to
2011 	rgn = &memblock.reserved.regions[0];  in memblock_free_near_max_check()
2034 	ASSERT_EQ(memblock.reserved.cnt, 1);  in memblock_free_near_max_check()
2035 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_free_near_max_check()
2043  * A test that tries to free a reserved region r3 that overlaps with two
2044  * existing reserved regions r1 and r2:
2054  * from the collection of reserved memory. Expect the total size of reserved
2062 	rgn1 = &memblock.reserved.regions[0];  in memblock_free_overlap_two_check()
2063 	rgn2 = &memblock.reserved.regions[1];  in memblock_free_overlap_two_check()
2097 	ASSERT_EQ(memblock.reserved.cnt, 2);  in memblock_free_overlap_two_check()
2098 	ASSERT_EQ(memblock.reserved.total_size, total_size);  in memblock_free_overlap_two_check()