memblock tests: add VERBOSE and MEMBLOCK_DEBUG Makefile options

Add and use functions and macros for printing verbose testing output.

If the Memblock simulator was compiled with VERBOSE=1:
- prefix_push(): appends the given string to a prefix string that will be printed in test_fail() and test_pass*().

- prefix_pop(): removes the last prefix from the prefix string.

- prefix_reset(): clears the prefix string.

- test_fail(): prints a message after a test fails containing the test number of the failing test and the prefix.

- test_pass(): prints a message after a test passes containing its test number and the prefix.

- test_print(): prints the given formatted output string.

- test_pass_pop(): runs test_pass() followed by prefix_pop().

- PREFIX_PUSH(): runs prefix_push(__func__).

If the Memblock simulator was not compiled with VERBOSE=1, these functions/macros do nothing.

Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT(). If the assert condition fails, these macros call test_fail() before executing assert().

Signed-off-by Rebecca Mckeever <[email protected]>

---
  tools/testing/memblock/tests/alloc_api.c      | 225 +++++++----
  .../memblock/tests/alloc_helpers_api.c        | 129 ++++---
  tools/testing/memblock/tests/alloc_nid_api.c  | 351 +++++++++++-------
  tools/testing/memblock/tests/basic_api.c      | 337 +++++++++++------
  tools/testing/memblock/tests/common.c         |  58 +++
  tools/testing/memblock/tests/common.h         |  62 ++++
  6 files changed, 818 insertions(+), 344 deletions(-)

tools/testing/memblock/tests/alloc_api.c +154 -71

index d1aa7e15c18d..a14f38eb8a89 100644
@@ -10,6 +10,8 @@ static int alloc_top_down_simple_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_2;
  	phys_addr_t expected_start;
 

@@ -19,12 +21,14 @@ static int alloc_top_down_simple_check(void)
 
  	allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == size);
-	assert(rgn->base == expected_start);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, expected_start);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -55,6 +59,8 @@ static int alloc_top_down_disjoint_check(void)
  	struct region r1;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r2_size = SZ_16;
  	/* Use custom alignment */
  	phys_addr_t alignment = SMP_CACHE_BYTES * 2;

@@ -73,15 +79,17 @@ static int alloc_top_down_disjoint_check(void)
 
  	allocated_ptr = memblock_alloc(r2_size, alignment);
 
-	assert(allocated_ptr);
-	assert(rgn1->size == r1.size);
-	assert(rgn1->base == r1.base);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn1->size, r1.size);
+	ASSERT_EQ(rgn1->base, r1.base);
 
-	assert(rgn2->size == r2_size);
-	assert(rgn2->base == expected_start);
+	ASSERT_EQ(rgn2->size, r2_size);
+	ASSERT_EQ(rgn2->base, expected_start);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -101,6 +109,8 @@ static int alloc_top_down_before_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	/*
  	 * The first region ends at the aligned address to test region merging
  	 */

@@ -114,12 +124,14 @@ static int alloc_top_down_before_check(void)
 
  	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == total_size);
-	assert(rgn->base == memblock_end_of_DRAM() - total_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -141,6 +153,8 @@ static int alloc_top_down_after_check(void)
  	struct region r1;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r2_size = SZ_512;
  	phys_addr_t total_size;
 

@@ -158,12 +172,14 @@ static int alloc_top_down_after_check(void)
 
  	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == total_size);
-	assert(rgn->base == r1.base - r2_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, r1.base - r2_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -186,6 +202,8 @@ static int alloc_top_down_second_fit_check(void)
  	struct region r1, r2;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_1K;
  	phys_addr_t total_size;
 

@@ -204,12 +222,14 @@ static int alloc_top_down_second_fit_check(void)
 
  	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == r2.size + r3_size);
-	assert(rgn->base == r2.base - r3_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, r2.size + r3_size);
+	ASSERT_EQ(rgn->base, r2.base - r3_size);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -231,6 +251,8 @@ static int alloc_in_between_generic_check(void)
  	struct region r1, r2;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t gap_size = SMP_CACHE_BYTES;
  	phys_addr_t r3_size = SZ_64;
  	/*

@@ -254,12 +276,14 @@ static int alloc_in_between_generic_check(void)
 
  	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == total_size);
-	assert(rgn->base == r1.base - r2.size - r3_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -281,6 +305,8 @@ static int alloc_small_gaps_generic_check(void)
  {
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t region_size = SZ_1K;
  	phys_addr_t gap_size = SZ_256;
  	phys_addr_t region_end;

@@ -296,7 +322,9 @@ static int alloc_small_gaps_generic_check(void)
 
  	allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
 
-	assert(!allocated_ptr);
+	ASSERT_EQ(allocated_ptr, NULL);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -309,6 +337,8 @@ static int alloc_all_reserved_generic_check(void)
  {
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	setup_memblock();
 
  	/* Simulate full memory */

@@ -316,7 +346,9 @@ static int alloc_all_reserved_generic_check(void)
 
  	allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
 
-	assert(!allocated_ptr);
+	ASSERT_EQ(allocated_ptr, NULL);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -338,6 +370,8 @@ static int alloc_no_space_generic_check(void)
  {
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	setup_memblock();
 
  	phys_addr_t available_size = SZ_256;

@@ -348,7 +382,9 @@ static int alloc_no_space_generic_check(void)
 
  	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
 
-	assert(!allocated_ptr);
+	ASSERT_EQ(allocated_ptr, NULL);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -369,6 +405,8 @@ static int alloc_limited_space_generic_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t available_size = SZ_256;
  	phys_addr_t reserved_size = MEM_SIZE - available_size;
 

@@ -379,12 +417,14 @@ static int alloc_limited_space_generic_check(void)
 
  	allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == MEM_SIZE);
-	assert(rgn->base == memblock_start_of_DRAM());
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, MEM_SIZE);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == MEM_SIZE);
+	test_pass_pop();
 
  	return 0;
  }

@@ -399,14 +439,18 @@ static int alloc_no_memory_generic_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
 
  	allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
 
-	assert(!allocated_ptr);
-	assert(rgn->size == 0);
-	assert(rgn->base == 0);
-	assert(memblock.reserved.total_size == 0);
+	ASSERT_EQ(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, 0);
+	ASSERT_EQ(rgn->base, 0);
+	ASSERT_EQ(memblock.reserved.total_size, 0);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -421,16 +465,20 @@ static int alloc_bottom_up_simple_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	setup_memblock();
 
  	allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == SZ_2);
-	assert(rgn->base == memblock_start_of_DRAM());
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, SZ_2);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == SZ_2);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, SZ_2);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -459,6 +507,8 @@ static int alloc_bottom_up_disjoint_check(void)
  	struct region r1;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r2_size = SZ_16;
  	/* Use custom alignment */
  	phys_addr_t alignment = SMP_CACHE_BYTES * 2;

@@ -477,16 +527,18 @@ static int alloc_bottom_up_disjoint_check(void)
 
  	allocated_ptr = memblock_alloc(r2_size, alignment);
 
-	assert(allocated_ptr);
+	ASSERT_NE(allocated_ptr, NULL);
 
-	assert(rgn1->size == r1.size);
-	assert(rgn1->base == r1.base);
+	ASSERT_EQ(rgn1->size, r1.size);
+	ASSERT_EQ(rgn1->base, r1.base);
 
-	assert(rgn2->size == r2_size);
-	assert(rgn2->base == expected_start);
+	ASSERT_EQ(rgn2->size, r2_size);
+	ASSERT_EQ(rgn2->base, expected_start);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -506,6 +558,8 @@ static int alloc_bottom_up_before_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_512;
  	phys_addr_t r2_size = SZ_128;
  	phys_addr_t total_size = r1_size + r2_size;

@@ -516,12 +570,14 @@ static int alloc_bottom_up_before_check(void)
 
  	allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == total_size);
-	assert(rgn->base == memblock_start_of_DRAM());
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -542,6 +598,8 @@ static int alloc_bottom_up_after_check(void)
  	struct region r1;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r2_size = SZ_512;
  	phys_addr_t total_size;
 

@@ -559,12 +617,14 @@ static int alloc_bottom_up_after_check(void)
 
  	allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == total_size);
-	assert(rgn->base == r1.base);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, r1.base);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -588,6 +648,8 @@ static int alloc_bottom_up_second_fit_check(void)
  	struct region r1, r2;
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_1K;
  	phys_addr_t total_size;
 

@@ -606,12 +668,14 @@ static int alloc_bottom_up_second_fit_check(void)
 
  	allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
 
-	assert(allocated_ptr);
-	assert(rgn->size == r2.size + r3_size);
-	assert(rgn->base == r2.base);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, r2.size + r3_size);
+	ASSERT_EQ(rgn->base, r2.base);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -619,6 +683,7 @@ static int alloc_bottom_up_second_fit_check(void)
  /* Test case wrappers */
  static int alloc_simple_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_top_down_simple_check();
  	memblock_set_bottom_up(true);

@@ -629,6 +694,7 @@ static int alloc_simple_check(void)
 
  static int alloc_disjoint_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_top_down_disjoint_check();
  	memblock_set_bottom_up(true);

@@ -639,6 +705,7 @@ static int alloc_disjoint_check(void)
 
  static int alloc_before_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_top_down_before_check();
  	memblock_set_bottom_up(true);

@@ -649,6 +716,7 @@ static int alloc_before_check(void)
 
  static int alloc_after_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_top_down_after_check();
  	memblock_set_bottom_up(true);

@@ -659,6 +727,7 @@ static int alloc_after_check(void)
 
  static int alloc_in_between_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_in_between_generic_check();
  	memblock_set_bottom_up(true);

@@ -669,6 +738,7 @@ static int alloc_in_between_check(void)
 
  static int alloc_second_fit_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_top_down_second_fit_check();
  	memblock_set_bottom_up(true);

@@ -679,6 +749,7 @@ static int alloc_second_fit_check(void)
 
  static int alloc_small_gaps_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_small_gaps_generic_check();
  	memblock_set_bottom_up(true);

@@ -689,6 +760,7 @@ static int alloc_small_gaps_check(void)
 
  static int alloc_all_reserved_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_all_reserved_generic_check();
  	memblock_set_bottom_up(true);

@@ -699,6 +771,7 @@ static int alloc_all_reserved_check(void)
 
  static int alloc_no_space_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_no_space_generic_check();
  	memblock_set_bottom_up(true);

@@ -709,6 +782,7 @@ static int alloc_no_space_check(void)
 
  static int alloc_limited_space_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_limited_space_generic_check();
  	memblock_set_bottom_up(true);

@@ -719,6 +793,7 @@ static int alloc_limited_space_check(void)
 
  static int alloc_no_memory_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_no_memory_generic_check();
  	memblock_set_bottom_up(true);

@@ -729,6 +804,12 @@ static int alloc_no_memory_check(void)
 
  int memblock_alloc_checks(void)
  {
+	const char *func_testing = "memblock_alloc";
+
+	prefix_reset();
+	prefix_push(func_testing);
+	test_print("Running %s tests...\n", func_testing);
+
  	reset_memblock_attributes();
  	dummy_physical_memory_init();
 

@@ -746,5 +827,7 @@ int memblock_alloc_checks(void)
 
  	dummy_physical_memory_cleanup();
 
+	prefix_pop();
+
  	return 0;
  }

tools/testing/memblock/tests/alloc_helpers_api.c +87 -42

index 963a966db461..1069b4bdd5fd 100644
@@ -21,6 +21,8 @@ static int alloc_from_simple_generic_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_16;
  	phys_addr_t min_addr;
 

@@ -31,14 +33,16 @@ static int alloc_from_simple_generic_check(void)
  	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, min_addr);
 
-	assert(rgn->size == size);
-	assert(rgn->base == min_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -64,6 +68,8 @@ static int alloc_from_misaligned_generic_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_32;
  	phys_addr_t min_addr;
 

@@ -75,14 +81,16 @@ static int alloc_from_misaligned_generic_check(void)
  	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -110,6 +118,8 @@ static int alloc_from_top_down_high_addr_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_32;
  	phys_addr_t min_addr;
 

@@ -120,12 +130,14 @@ static int alloc_from_top_down_high_addr_check(void)
 
  	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
 
-	assert(allocated_ptr);
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_end_of_DRAM() - SMP_CACHE_BYTES);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - SMP_CACHE_BYTES);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -151,6 +163,8 @@ static int alloc_from_top_down_no_space_above_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_64;
  	phys_addr_t r2_size = SZ_2;
  	phys_addr_t total_size = r1_size + r2_size;

@@ -165,12 +179,14 @@ static int alloc_from_top_down_no_space_above_check(void)
 
  	allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
 
-	assert(allocated_ptr);
-	assert(rgn->base == min_addr - r1_size);
-	assert(rgn->size == total_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->base, min_addr - r1_size);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -186,6 +202,8 @@ static int alloc_from_top_down_min_addr_cap_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_64;
  	phys_addr_t min_addr;
  	phys_addr_t start_addr;

@@ -199,12 +217,14 @@ static int alloc_from_top_down_min_addr_cap_check(void)
 
  	allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
 
-	assert(allocated_ptr);
-	assert(rgn->base == start_addr);
-	assert(rgn->size == MEM_SIZE);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->base, start_addr);
+	ASSERT_EQ(rgn->size, MEM_SIZE);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == MEM_SIZE);
+	test_pass_pop();
 
  	return 0;
  }

@@ -230,6 +250,8 @@ static int alloc_from_bottom_up_high_addr_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_32;
  	phys_addr_t min_addr;
 

@@ -240,12 +262,14 @@ static int alloc_from_bottom_up_high_addr_check(void)
 
  	allocated_ptr = memblock_alloc_from(size, SMP_CACHE_BYTES, min_addr);
 
-	assert(allocated_ptr);
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_start_of_DRAM());
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -270,6 +294,8 @@ static int alloc_from_bottom_up_no_space_above_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_64;
  	phys_addr_t min_addr;
  	phys_addr_t r2_size;

@@ -284,12 +310,14 @@ static int alloc_from_bottom_up_no_space_above_check(void)
 
  	allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
 
-	assert(allocated_ptr);
-	assert(rgn->base == memblock_start_of_DRAM());
-	assert(rgn->size == r1_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
+	ASSERT_EQ(rgn->size, r1_size);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == r1_size + r2_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, r1_size + r2_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -304,6 +332,8 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
  	struct memblock_region *rgn = &memblock.reserved.regions[0];
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_64;
  	phys_addr_t min_addr;
  	phys_addr_t start_addr;

@@ -315,12 +345,14 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
 
  	allocated_ptr = memblock_alloc_from(r1_size, SMP_CACHE_BYTES, min_addr);
 
-	assert(allocated_ptr);
-	assert(rgn->base == start_addr);
-	assert(rgn->size == r1_size);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(rgn->base, start_addr);
+	ASSERT_EQ(rgn->size, r1_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == r1_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, r1_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -328,6 +360,7 @@ static int alloc_from_bottom_up_min_addr_cap_check(void)
  /* Test case wrappers */
  static int alloc_from_simple_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_from_simple_generic_check();
  	memblock_set_bottom_up(true);

@@ -338,6 +371,7 @@ static int alloc_from_simple_check(void)
 
  static int alloc_from_misaligned_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_from_misaligned_generic_check();
  	memblock_set_bottom_up(true);

@@ -348,6 +382,7 @@ static int alloc_from_misaligned_check(void)
 
  static int alloc_from_high_addr_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_from_top_down_high_addr_check();
  	memblock_set_bottom_up(true);

@@ -358,6 +393,7 @@ static int alloc_from_high_addr_check(void)
 
  static int alloc_from_no_space_above_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_from_top_down_no_space_above_check();
  	memblock_set_bottom_up(true);

@@ -368,6 +404,7 @@ static int alloc_from_no_space_above_check(void)
 
  static int alloc_from_min_addr_cap_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_from_top_down_min_addr_cap_check();
  	memblock_set_bottom_up(true);

@@ -378,6 +415,12 @@ static int alloc_from_min_addr_cap_check(void)
 
  int memblock_alloc_helpers_checks(void)
  {
+	const char *func_testing = "memblock_alloc_from";
+
+	prefix_reset();
+	prefix_push(func_testing);
+	test_print("Running %s tests...\n", func_testing);
+
  	reset_memblock_attributes();
  	dummy_physical_memory_init();
 

@@ -389,5 +432,7 @@ int memblock_alloc_helpers_checks(void)
 
  	dummy_physical_memory_cleanup();
 
+	prefix_pop();
+
  	return 0;
  }

tools/testing/memblock/tests/alloc_nid_api.c +226 -125

index 6390206e50e1..255fd514e9f5 100644
@@ -21,6 +21,8 @@ static int alloc_try_nid_top_down_simple_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_128;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -36,15 +38,17 @@ static int alloc_try_nid_top_down_simple_check(void)
  	b = (char *)allocated_ptr;
  	rgn_end = rgn->base + rgn->size;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, max_addr - size);
+	ASSERT_EQ(rgn_end, max_addr);
 
-	assert(rgn->size == size);
-	assert(rgn->base == max_addr - size);
-	assert(rgn_end == max_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -72,6 +76,8 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_128;
  	phys_addr_t misalign = SZ_2;
  	phys_addr_t min_addr;

@@ -88,15 +94,17 @@ static int alloc_try_nid_top_down_end_misaligned_check(void)
  	b = (char *)allocated_ptr;
  	rgn_end = rgn->base + rgn->size;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn->size == size);
-	assert(rgn->base == max_addr - size - misalign);
-	assert(rgn_end < max_addr);
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, max_addr - size - misalign);
+	ASSERT_LT(rgn_end, max_addr);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -122,6 +130,8 @@ static int alloc_try_nid_exact_address_generic_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_1K;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -137,15 +147,17 @@ static int alloc_try_nid_exact_address_generic_check(void)
  	b = (char *)allocated_ptr;
  	rgn_end = rgn->base + rgn->size;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, min_addr);
+	ASSERT_EQ(rgn_end, max_addr);
 
-	assert(rgn->size == size);
-	assert(rgn->base == min_addr);
-	assert(rgn_end == max_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -173,6 +185,8 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_256;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -186,14 +200,16 @@ static int alloc_try_nid_top_down_narrow_range_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, max_addr - size);
 
-	assert(rgn->size == size);
-	assert(rgn->base == max_addr - size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -222,6 +238,8 @@ static int alloc_try_nid_low_max_generic_check(void)
  {
  	void *allocated_ptr = NULL;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_1K;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -234,7 +252,9 @@ static int alloc_try_nid_low_max_generic_check(void)
  	allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
  					       min_addr, max_addr, NUMA_NO_NODE);
 
-	assert(!allocated_ptr);
+	ASSERT_EQ(allocated_ptr, NULL);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -259,6 +279,8 @@ static int alloc_try_nid_min_reserved_generic_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_128;
  	phys_addr_t r2_size = SZ_64;
  	phys_addr_t total_size = r1_size + r2_size;

@@ -278,14 +300,16 @@ static int alloc_try_nid_min_reserved_generic_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn->size == total_size);
-	assert(rgn->base == reserved_base);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, reserved_base);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -310,6 +334,8 @@ static int alloc_try_nid_max_reserved_generic_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r1_size = SZ_64;
  	phys_addr_t r2_size = SZ_128;
  	phys_addr_t total_size = r1_size + r2_size;

@@ -327,14 +353,16 @@ static int alloc_try_nid_max_reserved_generic_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, min_addr);
 
-	assert(rgn->size == total_size);
-	assert(rgn->base == min_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -364,6 +392,8 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
  	char *b;
  	struct region r1, r2;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_64;
  	phys_addr_t gap_size = SMP_CACHE_BYTES;
  	phys_addr_t total_size;

@@ -389,17 +419,19 @@ static int alloc_try_nid_top_down_reserved_with_space_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn1->size, r1.size + r3_size);
+	ASSERT_EQ(rgn1->base, max_addr - r3_size);
 
-	assert(rgn1->size == r1.size + r3_size);
-	assert(rgn1->base == max_addr - r3_size);
+	ASSERT_EQ(rgn2->size, r2.size);
+	ASSERT_EQ(rgn2->base, r2.base);
 
-	assert(rgn2->size == r2.size);
-	assert(rgn2->base == r2.base);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -427,6 +459,8 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
  	char *b;
  	struct region r1, r2;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_64;
  	phys_addr_t total_size;
  	phys_addr_t max_addr;

@@ -451,14 +485,16 @@ static int alloc_try_nid_reserved_full_merge_generic_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn->size == total_size);
-	assert(rgn->base == r2.base);
+	ASSERT_EQ(rgn->size, total_size);
+	ASSERT_EQ(rgn->base, r2.base);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -489,6 +525,8 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
  	char *b;
  	struct region r1, r2;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_256;
  	phys_addr_t gap_size = SMP_CACHE_BYTES;
  	phys_addr_t total_size;

@@ -514,17 +552,19 @@ static int alloc_try_nid_top_down_reserved_no_space_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn1->size, r1.size);
+	ASSERT_EQ(rgn1->base, r1.base);
 
-	assert(rgn1->size == r1.size);
-	assert(rgn1->base == r1.base);
+	ASSERT_EQ(rgn2->size, r2.size + r3_size);
+	ASSERT_EQ(rgn2->base, r2.base - r3_size);
 
-	assert(rgn2->size == r2.size + r3_size);
-	assert(rgn2->base == r2.base - r3_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -554,6 +594,8 @@ static int alloc_try_nid_reserved_all_generic_check(void)
  	void *allocated_ptr = NULL;
  	struct region r1, r2;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_256;
  	phys_addr_t gap_size = SMP_CACHE_BYTES;
  	phys_addr_t max_addr;

@@ -576,7 +618,9 @@ static int alloc_try_nid_reserved_all_generic_check(void)
  	allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
  					       min_addr, max_addr, NUMA_NO_NODE);
 
-	assert(!allocated_ptr);
+	ASSERT_EQ(allocated_ptr, NULL);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -592,6 +636,8 @@ static int alloc_try_nid_top_down_cap_max_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_256;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -605,14 +651,16 @@ static int alloc_try_nid_top_down_cap_max_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
 
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_end_of_DRAM() - size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -628,6 +676,8 @@ static int alloc_try_nid_top_down_cap_min_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_1K;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -641,14 +691,16 @@ static int alloc_try_nid_top_down_cap_min_check(void)
  					       min_addr, max_addr, NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_end_of_DRAM() - size);
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -673,6 +725,8 @@ static int alloc_try_nid_bottom_up_simple_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_128;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -689,15 +743,17 @@ static int alloc_try_nid_bottom_up_simple_check(void)
  	b = (char *)allocated_ptr;
  	rgn_end = rgn->base + rgn->size;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, min_addr);
+	ASSERT_LT(rgn_end, max_addr);
 
-	assert(rgn->size == size);
-	assert(rgn->base == min_addr);
-	assert(rgn_end < max_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -725,6 +781,8 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_128;
  	phys_addr_t misalign = SZ_2;
  	phys_addr_t min_addr;

@@ -742,15 +800,17 @@ static int alloc_try_nid_bottom_up_start_misaligned_check(void)
  	b = (char *)allocated_ptr;
  	rgn_end = rgn->base + rgn->size;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
+	ASSERT_LT(rgn_end, max_addr);
 
-	assert(rgn->size == size);
-	assert(rgn->base == min_addr + (SMP_CACHE_BYTES - misalign));
-	assert(rgn_end < max_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -778,6 +838,8 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_256;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -792,14 +854,16 @@ static int alloc_try_nid_bottom_up_narrow_range_check(void)
  					       NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_start_of_DRAM());
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -829,6 +893,8 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
  	char *b;
  	struct region r1, r2;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_64;
  	phys_addr_t gap_size = SMP_CACHE_BYTES;
  	phys_addr_t total_size;

@@ -855,17 +921,19 @@ static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
  					       NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
 
-	assert(rgn1->size == r1.size);
-	assert(rgn1->base == max_addr);
+	ASSERT_EQ(rgn1->size, r1.size);
+	ASSERT_EQ(rgn1->base, max_addr);
 
-	assert(rgn2->size == r2.size + r3_size);
-	assert(rgn2->base == r2.base);
+	ASSERT_EQ(rgn2->size, r2.size + r3_size);
+	ASSERT_EQ(rgn2->base, r2.base);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -899,6 +967,8 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
  	char *b;
  	struct region r1, r2;
 
+	PREFIX_PUSH();
+
  	phys_addr_t r3_size = SZ_256;
  	phys_addr_t gap_size = SMP_CACHE_BYTES;
  	phys_addr_t total_size;

@@ -925,20 +995,22 @@ static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
  					       NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn3->size, r3_size);
+	ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
 
-	assert(rgn3->size == r3_size);
-	assert(rgn3->base == memblock_start_of_DRAM());
+	ASSERT_EQ(rgn2->size, r2.size);
+	ASSERT_EQ(rgn2->base, r2.base);
 
-	assert(rgn2->size == r2.size);
-	assert(rgn2->base == r2.base);
+	ASSERT_EQ(rgn1->size, r1.size);
+	ASSERT_EQ(rgn1->base, r1.base);
 
-	assert(rgn1->size == r1.size);
-	assert(rgn1->base == r1.base);
+	ASSERT_EQ(memblock.reserved.cnt, 3);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 3);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -954,6 +1026,8 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_256;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -968,14 +1042,16 @@ static int alloc_try_nid_bottom_up_cap_max_check(void)
  					       NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, min_addr);
 
-	assert(rgn->size == size);
-	assert(rgn->base == min_addr);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -991,6 +1067,8 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
  	void *allocated_ptr = NULL;
  	char *b;
 
+	PREFIX_PUSH();
+
  	phys_addr_t size = SZ_1K;
  	phys_addr_t min_addr;
  	phys_addr_t max_addr;

@@ -1005,14 +1083,16 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
  					       NUMA_NO_NODE);
  	b = (char *)allocated_ptr;
 
-	assert(allocated_ptr);
-	assert(*b == 0);
+	ASSERT_NE(allocated_ptr, NULL);
+	ASSERT_EQ(*b, 0);
+
+	ASSERT_EQ(rgn->size, size);
+	ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
 
-	assert(rgn->size == size);
-	assert(rgn->base == memblock_start_of_DRAM());
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -1020,6 +1100,7 @@ static int alloc_try_nid_bottom_up_cap_min_check(void)
  /* Test case wrappers */
  static int alloc_try_nid_simple_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_simple_check();
  	memblock_set_bottom_up(true);

@@ -1030,6 +1111,7 @@ static int alloc_try_nid_simple_check(void)
 
  static int alloc_try_nid_misaligned_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_end_misaligned_check();
  	memblock_set_bottom_up(true);

@@ -1040,6 +1122,7 @@ static int alloc_try_nid_misaligned_check(void)
 
  static int alloc_try_nid_narrow_range_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_narrow_range_check();
  	memblock_set_bottom_up(true);

@@ -1050,6 +1133,7 @@ static int alloc_try_nid_narrow_range_check(void)
 
  static int alloc_try_nid_reserved_with_space_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_reserved_with_space_check();
  	memblock_set_bottom_up(true);

@@ -1060,6 +1144,7 @@ static int alloc_try_nid_reserved_with_space_check(void)
 
  static int alloc_try_nid_reserved_no_space_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_reserved_no_space_check();
  	memblock_set_bottom_up(true);

@@ -1070,6 +1155,7 @@ static int alloc_try_nid_reserved_no_space_check(void)
 
  static int alloc_try_nid_cap_max_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_cap_max_check();
  	memblock_set_bottom_up(true);

@@ -1080,6 +1166,7 @@ static int alloc_try_nid_cap_max_check(void)
 
  static int alloc_try_nid_cap_min_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_top_down_cap_min_check();
  	memblock_set_bottom_up(true);

@@ -1090,6 +1177,7 @@ static int alloc_try_nid_cap_min_check(void)
 
  static int alloc_try_nid_min_reserved_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_min_reserved_generic_check();
  	memblock_set_bottom_up(true);

@@ -1100,6 +1188,7 @@ static int alloc_try_nid_min_reserved_check(void)
 
  static int alloc_try_nid_max_reserved_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_max_reserved_generic_check();
  	memblock_set_bottom_up(true);

@@ -1110,6 +1199,7 @@ static int alloc_try_nid_max_reserved_check(void)
 
  static int alloc_try_nid_exact_address_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_exact_address_generic_check();
  	memblock_set_bottom_up(true);

@@ -1120,6 +1210,7 @@ static int alloc_try_nid_exact_address_check(void)
 
  static int alloc_try_nid_reserved_full_merge_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_reserved_full_merge_generic_check();
  	memblock_set_bottom_up(true);

@@ -1130,6 +1221,7 @@ static int alloc_try_nid_reserved_full_merge_check(void)
 
  static int alloc_try_nid_reserved_all_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_reserved_all_generic_check();
  	memblock_set_bottom_up(true);

@@ -1140,6 +1232,7 @@ static int alloc_try_nid_reserved_all_check(void)
 
  static int alloc_try_nid_low_max_check(void)
  {
+	test_print("\tRunning %s...\n", __func__);
  	memblock_set_bottom_up(false);
  	alloc_try_nid_low_max_generic_check();
  	memblock_set_bottom_up(true);

@@ -1150,6 +1243,12 @@ static int alloc_try_nid_low_max_check(void)
 
  int memblock_alloc_nid_checks(void)
  {
+	const char *func_testing = "memblock_alloc_try_nid";
+
+	prefix_reset();
+	prefix_push(func_testing);
+	test_print("Running %s tests...\n", func_testing);
+
  	reset_memblock_attributes();
  	dummy_physical_memory_init();
 

@@ -1170,5 +1269,7 @@ int memblock_alloc_nid_checks(void)
 
  	dummy_physical_memory_cleanup();
 
+	prefix_pop();
+
  	return 0;
  }

tools/testing/memblock/tests/basic_api.c +231 -106

index a7bc180316d6..66f46f261e66 100644
@@ -4,21 +4,29 @@
  #include "basic_api.h"
 
  #define EXPECTED_MEMBLOCK_REGIONS			128
+#define FUNC_ADD					"memblock_add"
+#define FUNC_RESERVE					"memblock_reserve"
+#define FUNC_REMOVE					"memblock_remove"
+#define FUNC_FREE					"memblock_free"
 
  static int memblock_initialization_check(void)
  {
-	assert(memblock.memory.regions);
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
-	assert(strcmp(memblock.memory.name, "memory") == 0);
+	PREFIX_PUSH();
 
-	assert(memblock.reserved.regions);
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.memory.max == EXPECTED_MEMBLOCK_REGIONS);
-	assert(strcmp(memblock.reserved.name, "reserved") == 0);
+	ASSERT_NE(memblock.memory.regions, NULL);
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
+	ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
 
-	assert(!memblock.bottom_up);
-	assert(memblock.current_limit == MEMBLOCK_ALLOC_ANYWHERE);
+	ASSERT_NE(memblock.reserved.regions, NULL);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS);
+	ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
+
+	ASSERT_EQ(memblock.bottom_up, false);
+	ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -40,14 +48,18 @@ static int memblock_add_simple_check(void)
  		.size = SZ_4M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_add(r.base, r.size);
 
-	assert(rgn->base == r.base);
-	assert(rgn->size == r.size);
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, r.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, r.size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == r.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -69,18 +81,22 @@ static int memblock_add_node_simple_check(void)
  		.size = SZ_16M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
 
-	assert(rgn->base == r.base);
-	assert(rgn->size == r.size);
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, r.size);
  #ifdef CONFIG_NUMA
-	assert(rgn->nid == 1);
+	ASSERT_EQ(rgn->nid, 1);
  #endif
-	assert(rgn->flags == MEMBLOCK_HOTPLUG);
+	ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, r.size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == r.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -113,18 +129,22 @@ static int memblock_add_disjoint_check(void)
  		.size = SZ_8K
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_add(r2.base, r2.size);
 
-	assert(rgn1->base == r1.base);
-	assert(rgn1->size == r1.size);
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1.size);
+
+	ASSERT_EQ(rgn2->base, r2.base);
+	ASSERT_EQ(rgn2->size, r2.size);
 
-	assert(rgn2->base == r2.base);
-	assert(rgn2->size == r2.size);
+	ASSERT_EQ(memblock.memory.cnt, 2);
+	ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
 
-	assert(memblock.memory.cnt == 2);
-	assert(memblock.memory.total_size == r1.size + r2.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -162,17 +182,21 @@ static int memblock_add_overlap_top_check(void)
  		.size = SZ_512M
  	};
 
+	PREFIX_PUSH();
+
  	total_size = (r1.base - r2.base) + r1.size;
 
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_add(r2.base, r2.size);
 
-	assert(rgn->base == r2.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r2.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -210,17 +234,21 @@ static int memblock_add_overlap_bottom_check(void)
  		.size = SZ_1G
  	};
 
+	PREFIX_PUSH();
+
  	total_size = (r2.base - r1.base) + r2.size;
 
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_add(r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -255,15 +283,19 @@ static int memblock_add_within_check(void)
  		.size = SZ_1M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_add(r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == r1.size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, r1.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, r1.size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == r1.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -279,19 +311,27 @@ static int memblock_add_twice_check(void)
  		.size = SZ_2M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
 
  	memblock_add(r.base, r.size);
  	memblock_add(r.base, r.size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == r.size);
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, r.size);
+
+	test_pass_pop();
 
  	return 0;
  }
 
  static int memblock_add_checks(void)
  {
+	prefix_reset();
+	prefix_push(FUNC_ADD);
+	test_print("Running %s tests...\n", FUNC_ADD);
+
  	memblock_add_simple_check();
  	memblock_add_node_simple_check();
  	memblock_add_disjoint_check();

@@ -300,6 +340,8 @@ static int memblock_add_checks(void)
  	memblock_add_within_check();
  	memblock_add_twice_check();
 
+	prefix_pop();
+
  	return 0;
  }
 

@@ -320,11 +362,15 @@ static int memblock_reserve_simple_check(void)
  		.size = SZ_128M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_reserve(r.base, r.size);
 
-	assert(rgn->base == r.base);
-	assert(rgn->size == r.size);
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, r.size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -356,18 +402,22 @@ static int memblock_reserve_disjoint_check(void)
  		.size = SZ_512M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_reserve(r2.base, r2.size);
 
-	assert(rgn1->base == r1.base);
-	assert(rgn1->size == r1.size);
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1.size);
+
+	ASSERT_EQ(rgn2->base, r2.base);
+	ASSERT_EQ(rgn2->size, r2.size);
 
-	assert(rgn2->base == r2.base);
-	assert(rgn2->size == r2.size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == r1.size + r2.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -406,17 +456,21 @@ static int memblock_reserve_overlap_top_check(void)
  		.size = SZ_1G
  	};
 
+	PREFIX_PUSH();
+
  	total_size = (r1.base - r2.base) + r1.size;
 
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_reserve(r2.base, r2.size);
 
-	assert(rgn->base == r2.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r2.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -455,17 +509,21 @@ static int memblock_reserve_overlap_bottom_check(void)
  		.size = SZ_128K
  	};
 
+	PREFIX_PUSH();
+
  	total_size = (r2.base - r1.base) + r2.size;
 
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_reserve(r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -502,15 +560,19 @@ static int memblock_reserve_within_check(void)
  		.size = SZ_64K
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_reserve(r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == r1.size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, r1.size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, r1.size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == r1.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -527,19 +589,27 @@ static int memblock_reserve_twice_check(void)
  		.size = SZ_2M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
 
  	memblock_reserve(r.base, r.size);
  	memblock_reserve(r.base, r.size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == r.size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, r.size);
+
+	test_pass_pop();
 
  	return 0;
  }
 
  static int memblock_reserve_checks(void)
  {
+	prefix_reset();
+	prefix_push(FUNC_RESERVE);
+	test_print("Running %s tests...\n", FUNC_RESERVE);
+
  	memblock_reserve_simple_check();
  	memblock_reserve_disjoint_check();
  	memblock_reserve_overlap_top_check();

@@ -547,6 +617,8 @@ static int memblock_reserve_checks(void)
  	memblock_reserve_within_check();
  	memblock_reserve_twice_check();
 
+	prefix_pop();
+
  	return 0;
  }
 

@@ -581,16 +653,20 @@ static int memblock_remove_simple_check(void)
  		.size = SZ_4M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_add(r2.base, r2.size);
  	memblock_remove(r1.base, r1.size);
 
-	assert(rgn->base == r2.base);
-	assert(rgn->size == r2.size);
+	ASSERT_EQ(rgn->base, r2.base);
+	ASSERT_EQ(rgn->size, r2.size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == r2.size);
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, r2.size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -626,15 +702,19 @@ static int memblock_remove_absent_check(void)
  		.size = SZ_1G
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_remove(r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == r1.size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, r1.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, r1.size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == r1.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -674,6 +754,8 @@ static int memblock_remove_overlap_top_check(void)
  		.size = SZ_32M
  	};
 
+	PREFIX_PUSH();
+
  	r1_end = r1.base + r1.size;
  	r2_end = r2.base + r2.size;
  	total_size = r1_end - r2_end;

@@ -682,11 +764,13 @@ static int memblock_remove_overlap_top_check(void)
  	memblock_add(r1.base, r1.size);
  	memblock_remove(r2.base, r2.size);
 
-	assert(rgn->base == r1.base + r2.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r1.base + r2.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -724,17 +808,22 @@ static int memblock_remove_overlap_bottom_check(void)
  		.size = SZ_256M
  	};
 
+	PREFIX_PUSH();
+
  	total_size = r2.base - r1.base;
 
  	reset_memblock_regions();
  	memblock_add(r1.base, r1.size);
  	memblock_remove(r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
+
+	test_pass_pop();
 
-	assert(memblock.memory.cnt == 1);
-	assert(memblock.memory.total_size == total_size);
  	return 0;
  }
 

@@ -774,6 +863,8 @@ static int memblock_remove_within_check(void)
  		.size = SZ_1M
  	};
 
+	PREFIX_PUSH();
+
  	r1_size = r2.base - r1.base;
  	r2_size = (r1.base + r1.size) - (r2.base + r2.size);
  	total_size = r1_size + r2_size;

@@ -782,26 +873,34 @@ static int memblock_remove_within_check(void)
  	memblock_add(r1.base, r1.size);
  	memblock_remove(r2.base, r2.size);
 
-	assert(rgn1->base == r1.base);
-	assert(rgn1->size == r1_size);
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1_size);
+
+	ASSERT_EQ(rgn2->base, r2.base + r2.size);
+	ASSERT_EQ(rgn2->size, r2_size);
 
-	assert(rgn2->base == r2.base + r2.size);
-	assert(rgn2->size == r2_size);
+	ASSERT_EQ(memblock.memory.cnt, 2);
+	ASSERT_EQ(memblock.memory.total_size, total_size);
 
-	assert(memblock.memory.cnt == 2);
-	assert(memblock.memory.total_size == total_size);
+	test_pass_pop();
 
  	return 0;
  }
 
  static int memblock_remove_checks(void)
  {
+	prefix_reset();
+	prefix_push(FUNC_REMOVE);
+	test_print("Running %s tests...\n", FUNC_REMOVE);
+
  	memblock_remove_simple_check();
  	memblock_remove_absent_check();
  	memblock_remove_overlap_top_check();
  	memblock_remove_overlap_bottom_check();
  	memblock_remove_within_check();
 
+	prefix_pop();
+
  	return 0;
  }
 

@@ -835,16 +934,20 @@ static int memblock_free_simple_check(void)
  		.size = SZ_1M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_reserve(r2.base, r2.size);
  	memblock_free((void *)r1.base, r1.size);
 
-	assert(rgn->base == r2.base);
-	assert(rgn->size == r2.size);
+	ASSERT_EQ(rgn->base, r2.base);
+	ASSERT_EQ(rgn->size, r2.size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, r2.size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == r2.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -880,15 +983,19 @@ static int memblock_free_absent_check(void)
  		.size = SZ_128M
  	};
 
+	PREFIX_PUSH();
+
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_free((void *)r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == r1.size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, r1.size);
+
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, r1.size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == r1.size);
+	test_pass_pop();
 
  	return 0;
  }

@@ -928,17 +1035,21 @@ static int memblock_free_overlap_top_check(void)
  		.size = SZ_8M
  	};
 
+	PREFIX_PUSH();
+
  	total_size = (r1.size + r1.base) - (r2.base + r2.size);
 
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_free((void *)r2.base, r2.size);
 
-	assert(rgn->base == r2.base + r2.size);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r2.base + r2.size);
+	ASSERT_EQ(rgn->size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -973,17 +1084,21 @@ static int memblock_free_overlap_bottom_check(void)
  		.size = SZ_32M
  	};
 
+	PREFIX_PUSH();
+
  	total_size = r2.base - r1.base;
 
  	reset_memblock_regions();
  	memblock_reserve(r1.base, r1.size);
  	memblock_free((void *)r2.base, r2.size);
 
-	assert(rgn->base == r1.base);
-	assert(rgn->size == total_size);
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, total_size);
 
-	assert(memblock.reserved.cnt == 1);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 1);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }

@@ -1024,6 +1139,8 @@ static int memblock_free_within_check(void)
  		.size = SZ_1M
  	};
 
+	PREFIX_PUSH();
+
  	r1_size = r2.base - r1.base;
  	r2_size = (r1.base + r1.size) - (r2.base + r2.size);
  	total_size = r1_size + r2_size;

@@ -1032,26 +1149,34 @@ static int memblock_free_within_check(void)
  	memblock_reserve(r1.base, r1.size);
  	memblock_free((void *)r2.base, r2.size);
 
-	assert(rgn1->base == r1.base);
-	assert(rgn1->size == r1_size);
+	ASSERT_EQ(rgn1->base, r1.base);
+	ASSERT_EQ(rgn1->size, r1_size);
 
-	assert(rgn2->base == r2.base + r2.size);
-	assert(rgn2->size == r2_size);
+	ASSERT_EQ(rgn2->base, r2.base + r2.size);
+	ASSERT_EQ(rgn2->size, r2_size);
 
-	assert(memblock.reserved.cnt == 2);
-	assert(memblock.reserved.total_size == total_size);
+	ASSERT_EQ(memblock.reserved.cnt, 2);
+	ASSERT_EQ(memblock.reserved.total_size, total_size);
+
+	test_pass_pop();
 
  	return 0;
  }
 
  static int memblock_free_checks(void)
  {
+	prefix_reset();
+	prefix_push(FUNC_FREE);
+	test_print("Running %s tests...\n", FUNC_FREE);
+
  	memblock_free_simple_check();
  	memblock_free_absent_check();
  	memblock_free_overlap_top_check();
  	memblock_free_overlap_bottom_check();
  	memblock_free_within_check();
 
+	prefix_pop();
+
  	return 0;
  }
 

tools/testing/memblock/tests/common.c +58 -0

index 62d3191f7c9a..e55b2a8bf0ff 100644
@@ -4,8 +4,12 @@
 
  #define INIT_MEMBLOCK_REGIONS			128
  #define INIT_MEMBLOCK_RESERVED_REGIONS		INIT_MEMBLOCK_REGIONS
+#define PREFIXES_LEN_MAX			256
+#define DELIM					": "
+#define DELIM_LEN				strlen(DELIM)
 
  static struct test_memory memory_block;
+static char __maybe_unused prefixes[PREFIXES_LEN_MAX];
 
  void reset_memblock_regions(void)
  {

@@ -46,3 +50,57 @@ void dummy_physical_memory_cleanup(void)
  {
  	free(memory_block.base);
  }
+
+#ifdef VERBOSE
+void test_fail(void)
+{
+	ksft_test_result_fail(": %sfailed\n", prefixes);
+}
+
+void test_pass(void)
+{
+	ksft_test_result_pass(": %spassed\n", prefixes);
+}
+
+void test_print(const char *fmt, ...)
+{
+	int saved_errno = errno;
+	va_list args;
+
+	va_start(args, fmt);
+	errno = saved_errno;
+	vprintf(fmt, args);
+	va_end(args);
+}
+
+void prefix_reset(void)
+{
+	memset(prefixes, 0, PREFIXES_LEN_MAX);
+}
+
+void prefix_push(const char *prefix)
+{
+	int prefix_max = PREFIXES_LEN_MAX - strlen(prefixes) - DELIM_LEN - 1;
+
+	assert(strlen(prefix) <= prefix_max);
+	strncat(prefixes, prefix, prefix_max);
+	strncat(prefixes, DELIM, PREFIXES_LEN_MAX - strlen(prefixes) - 1);
+}
+
+void prefix_pop(void)
+{
+	char *ptr;
+
+	ptr = strrchr(prefixes, DELIM[0]);
+	if (!ptr)
+		prefixes[0] = 0;
+	else
+		*(ptr) = 0;
+
+	ptr = strrchr(prefixes, DELIM[0]);
+	if (!ptr)
+		prefixes[0] = 0;
+	else
+		*(ptr + DELIM_LEN) = 0;
+}
+#endif /* VERBOSE */

tools/testing/memblock/tests/common.h +62 -0

index 619054d03219..46de86a755f3 100644
@@ -7,9 +7,49 @@
  #include <linux/types.h>
  #include <linux/memblock.h>
  #include <linux/sizes.h>
+#include <linux/printk.h>
+#include <../selftests/kselftest.h>
 
  #define MEM_SIZE SZ_16K
 
+/**
+ * ASSERT_EQ():
+ * Check the condition
+ * @_expected == @_seen
+ * If false, print failed test message (if in VERBOSE mode) and then assert
+ */
+#define ASSERT_EQ(_expected, _seen) do { \
+	if ((_expected) != (_seen)) \
+		test_fail(); \
+	assert((_expected) == (_seen)); \
+} while (0)
+
+/**
+ * ASSERT_NE():
+ * Check the condition
+ * @_expected != @_seen
+ * If false, print failed test message (if in VERBOSE mode) and then assert
+ */
+#define ASSERT_NE(_expected, _seen) do { \
+	if ((_expected) == (_seen)) \
+		test_fail(); \
+	assert((_expected) != (_seen)); \
+} while (0)
+
+/**
+ * ASSERT_LT():
+ * Check the condition
+ * @_expected < @_seen
+ * If false, print failed test message (if in VERBOSE mode) and then assert
+ */
+#define ASSERT_LT(_expected, _seen) do { \
+	if ((_expected) >= (_seen)) \
+		test_fail(); \
+	assert((_expected) < (_seen)); \
+} while (0)
+
+#define PREFIX_PUSH() prefix_push(__func__)
+
  /*
   * Available memory registered with memblock needs to be valid for allocs
   * test to run. This is a convenience wrapper for memory allocated in

@@ -31,4 +71,26 @@ void setup_memblock(void);
  void dummy_physical_memory_init(void);
  void dummy_physical_memory_cleanup(void);
 
+#ifdef VERBOSE
+void test_fail(void);
+void test_pass(void);
+void test_print(const char *fmt, ...);
+void prefix_reset(void);
+void prefix_push(const char *prefix);
+void prefix_pop(void);
+#else
+static inline void test_fail(void) {}
+static inline void test_pass(void) {}
+static inline void test_print(const char *fmt, ...) {}
+static inline void prefix_reset(void) {}
+static inline void prefix_push(const char *prefix) {}
+static inline void prefix_pop(void) {}
+#endif /* VERBOSE */
+
+static inline void test_pass_pop(void)
+{
+	test_pass();
+	prefix_pop();
+}
+
  #endif

Add and use functions and macros for printing verbose testing output.

If the Memblock simulator was compiled with VERBOSE=1:
- prefix_push(): appends the given string to a prefix string that will be printed in test_fail() and test_pass*().

- prefix_pop(): removes the last prefix from the prefix string.

- prefix_reset(): clears the prefix string.

- test_fail(): prints a message after a test fails containing the test number of the failing test and the prefix.

- test_pass(): prints a message after a test passes containing its test number and the prefix.

- test_print(): prints the given formatted output string.

- test_pass_pop(): runs test_pass() followed by prefix_pop().

- PREFIX_PUSH(): runs prefix_push(__func__).

If the Memblock simulator was not compiled with VERBOSE=1, these functions/macros do nothing.

Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT(). If the assert condition fails, these macros call test_fail() before executing assert().

Signed-off-by Rebecca Mckeever <[email protected]>

Quoted 30 lines · Rebecca Mckeever

Add and use functions and macros for printing verbose testing output.

If the Memblock simulator was compiled with VERBOSE=1:
- prefix_push(): appends the given string to a prefix string that will be printed in test_fail() and test_pass*().

- prefix_pop(): removes the last prefix from the prefix string.

- prefix_reset(): clears the prefix string.

- test_fail(): prints a message after a test fails containing the test number of the failing test and the prefix.

- test_pass(): prints a message after a test passes containing its test number and the prefix.

- test_print(): prints the given formatted output string.

- test_pass_pop(): runs test_pass() followed by prefix_pop().

- PREFIX_PUSH(): runs prefix_push(__func__).

If the Memblock simulator was not compiled with VERBOSE=1, these functions/macros do nothing.

Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT(). If the assert condition fails, these macros call test_fail() before executing assert().

Signed-off-by Rebecca Mckeever <[email protected]>

[...]

tools/testing/memblock/tests/common.c line 9

Quoted 12 lines

tools/testing/memblock/tests/common.c +3 -0

index 62d3191f7c9a..e55b2a8bf0ff 100644
@@ -4,8 +4,12 @@
 
 #define INIT_MEMBLOCK_REGIONS			128
 #define INIT_MEMBLOCK_RESERVED_REGIONS		INIT_MEMBLOCK_REGIONS
+#define PREFIXES_LEN_MAX			256
+#define DELIM					": "
+#define DELIM_LEN				strlen(DELIM)

Why not simply

#define PREFIXES_MAX 15
static const char * __maybe_unused prefixes[PREFIXES_MAX]; static int nr_prefixes;

And then simply insert/clear the corresponding prefixes[] pointer and update nr_prefixes?

When printing, you only have to walk prefixes from 0 ... nr_prefixes - 1 and print the values.

Avoids any string modifications.

Anyhow, this LGTM

Acked-by David Hildenbrand <[email protected]>

Signature · 3 lines

Thanks,

David / dhildenb

Quoted 60 lines · David Hildenbrand

Quoted 30 lines · Rebecca Mckeever

Add and use functions and macros for printing verbose testing output.

If the Memblock simulator was compiled with VERBOSE=1:
- prefix_push(): appends the given string to a prefix string that will be printed in test_fail() and test_pass*().

- prefix_pop(): removes the last prefix from the prefix string.

- prefix_reset(): clears the prefix string.

- test_fail(): prints a message after a test fails containing the test number of the failing test and the prefix.

- test_pass(): prints a message after a test passes containing its test number and the prefix.

- test_print(): prints the given formatted output string.

- test_pass_pop(): runs test_pass() followed by prefix_pop().

- PREFIX_PUSH(): runs prefix_push(__func__).

If the Memblock simulator was not compiled with VERBOSE=1, these functions/macros do nothing.

Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT(). If the assert condition fails, these macros call test_fail() before executing assert().

Signed-off-by Rebecca Mckeever <[email protected]>

[...]

tools/testing/memblock/tests/common.c line 9

Quoted 12 lines

tools/testing/memblock/tests/common.c +3 -0

index 62d3191f7c9a..e55b2a8bf0ff 100644
@@ -4,8 +4,12 @@
 
 #define INIT_MEMBLOCK_REGIONS			128
 #define INIT_MEMBLOCK_RESERVED_REGIONS		INIT_MEMBLOCK_REGIONS
+#define PREFIXES_LEN_MAX			256
+#define DELIM					": "
+#define DELIM_LEN				strlen(DELIM)

Why not simply

#define PREFIXES_MAX 15
static const char * __maybe_unused prefixes[PREFIXES_MAX]; static int nr_prefixes;

And then simply insert/clear the corresponding prefixes[] pointer and update nr_prefixes?

When printing, you only have to walk prefixes from 0 ... nr_prefixes - 1 and print the values.

Quoted 2 lines

Avoids any string modifications.

What is nr_prefixes? Number of prefixes? Currently, the longest prefix is 49 characters (alloc_try_nid_bottom_up_reserved_with_space_check), so I think PREFIXES_MAX would need to be at least 52 (including the delimiter), but let me know if I'm misunderstanding.

Quoted 61 lines · Rebecca Mckeever

Quoted 60 lines · David Hildenbrand

Quoted 30 lines · Rebecca Mckeever

Add and use functions and macros for printing verbose testing output.

If the Memblock simulator was compiled with VERBOSE=1:
- prefix_push(): appends the given string to a prefix string that will be printed in test_fail() and test_pass*().

- prefix_pop(): removes the last prefix from the prefix string.

- prefix_reset(): clears the prefix string.

- test_fail(): prints a message after a test fails containing the test number of the failing test and the prefix.

- test_pass(): prints a message after a test passes containing its test number and the prefix.

- test_print(): prints the given formatted output string.

- test_pass_pop(): runs test_pass() followed by prefix_pop().

- PREFIX_PUSH(): runs prefix_push(__func__).

If the Memblock simulator was not compiled with VERBOSE=1, these functions/macros do nothing.

Add the assert wrapper macros ASSERT_EQ(), ASSERT_NE(), and ASSERT_LT(). If the assert condition fails, these macros call test_fail() before executing assert().

Signed-off-by Rebecca Mckeever <[email protected]>

[...]

tools/testing/memblock/tests/common.c line 9

Quoted 12 lines

tools/testing/memblock/tests/common.c +3 -0

index 62d3191f7c9a..e55b2a8bf0ff 100644
@@ -4,8 +4,12 @@
 
 #define INIT_MEMBLOCK_REGIONS			128
 #define INIT_MEMBLOCK_RESERVED_REGIONS		INIT_MEMBLOCK_REGIONS
+#define PREFIXES_LEN_MAX			256
+#define DELIM					": "
+#define DELIM_LEN				strlen(DELIM)

Why not simply

#define PREFIXES_MAX 15
static const char * __maybe_unused prefixes[PREFIXES_MAX]; static int nr_prefixes;

And then simply insert/clear the corresponding prefixes[] pointer and update nr_prefixes?

When printing, you only have to walk prefixes from 0 ... nr_prefixes - 1 and print the values.

Quoted 6 lines

Quoted 2 lines

Avoids any string modifications.

What is nr_prefixes? Number of prefixes? Currently, the longest prefix is 49 characters (alloc_try_nid_bottom_up_reserved_with_space_check), so I think PREFIXES_MAX would need to be at least 52 (including the delimiter), but let me know if I'm misunderstanding.

nr_prefixes would be the current number of prefixes (not the length).

You be storing pointers to strings in the constant pool, not copying the strings over.

Signature · 3 lines

Thanks,

David / dhildenb