Add tests for memblock_trim_memory() for the following scenarios:
- all regions aligned
- one region unalign that is smaller than the alignment
- one region unaligned at the base
- one region unaligned at the end

Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
---
 tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++
 1 file changed, 223 insertions(+)

diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
index d7f008e7a12a..c8bb44f20846 100644
--- a/tools/testing/memblock/tests/basic_api.c
+++ b/tools/testing/memblock/tests/basic_api.c
@@ -8,6 +8,7 @@
 #define FUNC_RESERVE					"memblock_reserve"
 #define FUNC_REMOVE					"memblock_remove"
 #define FUNC_FREE					"memblock_free"
+#define FUNC_TRIM					"memblock_trim_memory"
 
 static int memblock_initialization_check(void)
 {
@@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void)
 	return 0;
 }
 
+/*
+ * A test that tries to trim memory when both ends of the memory region are
+ * aligned. Expect that the memory will not be trimmed. Expect the counter to
+ * not be updated.
+ */
+static int memblock_trim_memory_aligned_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r = {
+		.base = alignment,
+		.size = alignment * 4
+	};
+
+	PREFIX_PUSH();
+
+	reset_memblock_regions();
+	memblock_add(r.base, r.size);
+	memblock_trim_memory(alignment);
+
+	ASSERT_EQ(rgn->base, r.base);
+	ASSERT_EQ(rgn->size, r.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to trim memory when there are two available regions, r1 and
+ * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
+ * and smaller than the alignment:
+ *
+ *                                     alignment
+ *                                     |--------|
+ * |        +-----------------+        +------+   |
+ * |        |        r1       |        |  r2  |   |
+ * +--------+-----------------+--------+------+---+
+ *          ^        ^        ^        ^      ^
+ *          |________|________|________|      |
+ *                            |               Unaligned address
+ *                Aligned addresses
+ *
+ * Expect that r1 will not be trimmed and r2 will be removed. Expect the
+ * counter to be updated.
+ */
+static int memblock_trim_memory_too_small_check(void)
+{
+	struct memblock_region *rgn;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+
+	rgn = &memblock.memory.regions[0];
+
+	struct region r1 = {
+		.base = alignment,
+		.size = alignment * 2
+	};
+	struct region r2 = {
+		.base = alignment * 4,
+		.size = alignment - SZ_2
+	};
+
+	PREFIX_PUSH();
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_trim_memory(alignment);
+
+	ASSERT_EQ(rgn->base, r1.base);
+	ASSERT_EQ(rgn->size, r1.size);
+
+	ASSERT_EQ(memblock.memory.cnt, 1);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to trim memory when there are two available regions, r1 and
+ * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
+ * and aligned at the end:
+ *
+ *                               Unaligned address
+ *                                       |
+ *                                       v
+ * |        +-----------------+          +---------------+   |
+ * |        |        r1       |          |      r2       |   |
+ * +--------+-----------------+----------+---------------+---+
+ *          ^        ^        ^        ^        ^        ^
+ *          |________|________|________|________|________|
+ *                            |
+ *                    Aligned addresses
+ *
+ * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
+ * Expect the counter to not be updated.
+ */
+static int memblock_trim_memory_unaligned_base_check(void)
+{
+	struct memblock_region *rgn1, *rgn2;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+	phys_addr_t offset = SZ_2;
+	phys_addr_t r2_base, r2_size;
+
+	rgn1 = &memblock.memory.regions[0];
+	rgn2 = &memblock.memory.regions[1];
+
+	struct region r1 = {
+		.base = alignment,
+		.size = alignment * 2
+	};
+	struct region r2 = {
+		.base = alignment * 4 + offset,
+		.size = alignment * 2 - offset
+	};
+
+	PREFIX_PUSH();
+
+	r2_base = r2.base + (alignment - offset);
+	r2_size = r2.size - (alignment - offset);
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_trim_memory(alignment);
+
+	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_EQ(memblock.memory.cnt, 2);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+/*
+ * A test that tries to trim memory when there are two available regions, r1 and
+ * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
+ * and unaligned at the end:
+ *
+ *                                             Unaligned address
+ *                                                     |
+ *                                                     v
+ * |        +-----------------+        +---------------+   |
+ * |        |        r1       |        |      r2       |   |
+ * +--------+-----------------+--------+---------------+---+
+ *          ^        ^        ^        ^        ^        ^
+ *          |________|________|________|________|________|
+ *                            |
+ *                    Aligned addresses
+ *
+ * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
+ * Expect the counter to not be updated.
+ */
+static int memblock_trim_memory_unaligned_end_check(void)
+{
+	struct memblock_region *rgn1, *rgn2;
+	phys_addr_t alignment = SMP_CACHE_BYTES;
+	phys_addr_t offset = SZ_2;
+	phys_addr_t r2_size;
+
+	rgn1 = &memblock.memory.regions[0];
+	rgn2 = &memblock.memory.regions[1];
+
+	struct region r1 = {
+		.base = alignment,
+		.size = alignment * 2
+	};
+	struct region r2 = {
+		.base = alignment * 4,
+		.size = alignment * 2 - offset
+	};
+
+	PREFIX_PUSH();
+
+	r2_size = r2.size - (alignment - offset);
+
+	reset_memblock_regions();
+	memblock_add(r1.base, r1.size);
+	memblock_add(r2.base, r2.size);
+	memblock_trim_memory(alignment);
+
+	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_EQ(memblock.memory.cnt, 2);
+
+	test_pass_pop();
+
+	return 0;
+}
+
+static int memblock_trim_memory_checks(void)
+{
+	prefix_reset();
+	prefix_push(FUNC_TRIM);
+	test_print("Running %s tests...\n", FUNC_TRIM);
+
+	memblock_trim_memory_aligned_check();
+	memblock_trim_memory_too_small_check();
+	memblock_trim_memory_unaligned_base_check();
+	memblock_trim_memory_unaligned_end_check();
+
+	prefix_pop();
+
+	return 0;
+}
+
 int memblock_basic_checks(void)
 {
 	memblock_initialization_check();
@@ -1731,6 +1953,7 @@ int memblock_basic_checks(void)
 	memblock_remove_checks();
 	memblock_free_checks();
 	memblock_bottom_up_checks();
+	memblock_trim_memory_checks();
 
 	return 0;
 }
-- 
2.25.1

On 8/14/2022 1:54 PM, Rebecca Mckeever wrote:
> Add tests for memblock_trim_memory() for the following scenarios:
> - all regions aligned
> - one region unalign that is smaller than the alignment
> - one region unaligned at the base
> - one region unaligned at the end
> 
> Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> ---
>   tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++
>   1 file changed, 223 insertions(+)
> 
> diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> index d7f008e7a12a..c8bb44f20846 100644
> --- a/tools/testing/memblock/tests/basic_api.c
> +++ b/tools/testing/memblock/tests/basic_api.c
> @@ -8,6 +8,7 @@
>   #define FUNC_RESERVE					"memblock_reserve"
>   #define FUNC_REMOVE					"memblock_remove"
>   #define FUNC_FREE					"memblock_free"
> +#define FUNC_TRIM					"memblock_trim_memory"
>   
>   static int memblock_initialization_check(void)
>   {
> @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void)
>   	return 0;
>   }
>   
> +/*
> + * A test that tries to trim memory when both ends of the memory region are
> + * aligned. Expect that the memory will not be trimmed. Expect the counter to
> + * not be updated.
> + */
> +static int memblock_trim_memory_aligned_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r = {
> +		.base = alignment,
> +		.size = alignment * 4
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	reset_memblock_regions();
> +	memblock_add(r.base, r.size);
> +	memblock_trim_memory(alignment);
> +
> +	ASSERT_EQ(rgn->base, r.base);
> +	ASSERT_EQ(rgn->size, r.size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to trim memory when there are two available regions, r1 and
> + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
> + * and smaller than the alignment:
> + *
> + *                                     alignment
> + *                                     |--------|
> + * |        +-----------------+        +------+   |
> + * |        |        r1       |        |  r2  |   |
> + * +--------+-----------------+--------+------+---+
> + *          ^        ^        ^        ^      ^
> + *          |________|________|________|      |
> + *                            |               Unaligned address
> + *                Aligned addresses
> + *
> + * Expect that r1 will not be trimmed and r2 will be removed. Expect the
> + * counter to be updated.
> + */
> +static int memblock_trim_memory_too_small_check(void)
> +{
> +	struct memblock_region *rgn;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +
> +	rgn = &memblock.memory.regions[0];
> +
> +	struct region r1 = {
> +		.base = alignment,
> +		.size = alignment * 2
> +	};
> +	struct region r2 = {
> +		.base = alignment * 4,
> +		.size = alignment - SZ_2
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_trim_memory(alignment);
> +
> +	ASSERT_EQ(rgn->base, r1.base);
> +	ASSERT_EQ(rgn->size, r1.size);
> +
> +	ASSERT_EQ(memblock.memory.cnt, 1);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to trim memory when there are two available regions, r1 and
> + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
> + * and aligned at the end:
> + *
> + *                               Unaligned address
> + *                                       |
> + *                                       v
> + * |        +-----------------+          +---------------+   |
> + * |        |        r1       |          |      r2       |   |
> + * +--------+-----------------+----------+---------------+---+
> + *          ^        ^        ^        ^        ^        ^
> + *          |________|________|________|________|________|
> + *                            |
> + *                    Aligned addresses
> + *
> + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
> + * Expect the counter to not be updated.
> + */
> +static int memblock_trim_memory_unaligned_base_check(void)
> +{
> +	struct memblock_region *rgn1, *rgn2;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +	phys_addr_t offset = SZ_2;
> +	phys_addr_t r2_base, r2_size;
> +
> +	rgn1 = &memblock.memory.regions[0];
> +	rgn2 = &memblock.memory.regions[1];
> +
> +	struct region r1 = {
> +		.base = alignment,
> +		.size = alignment * 2
> +	};
> +	struct region r2 = {
> +		.base = alignment * 4 + offset,
> +		.size = alignment * 2 - offset
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	r2_base = r2.base + (alignment - offset);
> +	r2_size = r2.size - (alignment - offset);

Also the variable name.

> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_trim_memory(alignment);
> +
> +	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_EQ(memblock.memory.cnt, 2);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +/*
> + * A test that tries to trim memory when there are two available regions, r1 and
> + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
> + * and unaligned at the end:
> + *
> + *                                             Unaligned address
> + *                                                     |
> + *                                                     v
> + * |        +-----------------+        +---------------+   |
> + * |        |        r1       |        |      r2       |   |
> + * +--------+-----------------+--------+---------------+---+
> + *          ^        ^        ^        ^        ^        ^
> + *          |________|________|________|________|________|
> + *                            |
> + *                    Aligned addresses
> + *
> + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
								^
							at the end.
> + * Expect the counter to not be updated.
> + */
> +static int memblock_trim_memory_unaligned_end_check(void)
> +{
> +	struct memblock_region *rgn1, *rgn2;
> +	phys_addr_t alignment = SMP_CACHE_BYTES;
> +	phys_addr_t offset = SZ_2;
> +	phys_addr_t r2_size;
> +
> +	rgn1 = &memblock.memory.regions[0];
> +	rgn2 = &memblock.memory.regions[1];
> +
> +	struct region r1 = {
> +		.base = alignment,
> +		.size = alignment * 2
> +	};
> +	struct region r2 = {
> +		.base = alignment * 4,
> +		.size = alignment * 2 - offset
> +	};
> +
> +	PREFIX_PUSH();
> +
> +	r2_size = r2.size - (alignment - offset);
> +
> +	reset_memblock_regions();
> +	memblock_add(r1.base, r1.size);
> +	memblock_add(r2.base, r2.size);
> +	memblock_trim_memory(alignment);
> +
> +	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_EQ(memblock.memory.cnt, 2);
> +
> +	test_pass_pop();
> +
> +	return 0;
> +}
> +
> +static int memblock_trim_memory_checks(void)
> +{
> +	prefix_reset();
> +	prefix_push(FUNC_TRIM);
> +	test_print("Running %s tests...\n", FUNC_TRIM);
> +
> +	memblock_trim_memory_aligned_check();
> +	memblock_trim_memory_too_small_check();
> +	memblock_trim_memory_unaligned_base_check();
> +	memblock_trim_memory_unaligned_end_check();
> +
> +	prefix_pop();
> +
> +	return 0;
> +}
> +
>   int memblock_basic_checks(void)
>   {
>   	memblock_initialization_check();
> @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void)
>   	memblock_remove_checks();
>   	memblock_free_checks();
>   	memblock_bottom_up_checks();
> +	memblock_trim_memory_checks();
>   
>   	return 0;
>   }

Others looks good.

On Tue, Aug 16, 2022 at 09:46:11AM +0800, Huang, Shaoqin wrote:
> 
> 
> On 8/14/2022 1:54 PM, Rebecca Mckeever wrote:
> > Add tests for memblock_trim_memory() for the following scenarios:
> > - all regions aligned
> > - one region unalign that is smaller than the alignment
> > - one region unaligned at the base
> > - one region unaligned at the end
> > 
> > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
> > ---
> >   tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++
> >   1 file changed, 223 insertions(+)
> > 
> > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c
> > index d7f008e7a12a..c8bb44f20846 100644
> > --- a/tools/testing/memblock/tests/basic_api.c
> > +++ b/tools/testing/memblock/tests/basic_api.c
> > @@ -8,6 +8,7 @@
> >   #define FUNC_RESERVE					"memblock_reserve"
> >   #define FUNC_REMOVE					"memblock_remove"
> >   #define FUNC_FREE					"memblock_free"
> > +#define FUNC_TRIM					"memblock_trim_memory"
> >   static int memblock_initialization_check(void)
> >   {
> > @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void)
> >   	return 0;
> >   }
> > +/*
> > + * A test that tries to trim memory when both ends of the memory region are
> > + * aligned. Expect that the memory will not be trimmed. Expect the counter to
> > + * not be updated.
> > + */
> > +static int memblock_trim_memory_aligned_check(void)
> > +{
> > +	struct memblock_region *rgn;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +
> > +	rgn = &memblock.memory.regions[0];
> > +
> > +	struct region r = {
> > +		.base = alignment,
> > +		.size = alignment * 4
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r.base, r.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	ASSERT_EQ(rgn->base, r.base);
> > +	ASSERT_EQ(rgn->size, r.size);
> > +
> > +	ASSERT_EQ(memblock.memory.cnt, 1);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * A test that tries to trim memory when there are two available regions, r1 and
> > + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
> > + * and smaller than the alignment:
> > + *
> > + *                                     alignment
> > + *                                     |--------|
> > + * |        +-----------------+        +------+   |
> > + * |        |        r1       |        |  r2  |   |
> > + * +--------+-----------------+--------+------+---+
> > + *          ^        ^        ^        ^      ^
> > + *          |________|________|________|      |
> > + *                            |               Unaligned address
> > + *                Aligned addresses
> > + *
> > + * Expect that r1 will not be trimmed and r2 will be removed. Expect the
> > + * counter to be updated.
> > + */
> > +static int memblock_trim_memory_too_small_check(void)
> > +{
> > +	struct memblock_region *rgn;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +
> > +	rgn = &memblock.memory.regions[0];
> > +
> > +	struct region r1 = {
> > +		.base = alignment,
> > +		.size = alignment * 2
> > +	};
> > +	struct region r2 = {
> > +		.base = alignment * 4,
> > +		.size = alignment - SZ_2
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r1.base, r1.size);
> > +	memblock_add(r2.base, r2.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	ASSERT_EQ(rgn->base, r1.base);
> > +	ASSERT_EQ(rgn->size, r1.size);
> > +
> > +	ASSERT_EQ(memblock.memory.cnt, 1);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * A test that tries to trim memory when there are two available regions, r1 and
> > + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
> > + * and aligned at the end:
> > + *
> > + *                               Unaligned address
> > + *                                       |
> > + *                                       v
> > + * |        +-----------------+          +---------------+   |
> > + * |        |        r1       |          |      r2       |   |
> > + * +--------+-----------------+----------+---------------+---+
> > + *          ^        ^        ^        ^        ^        ^
> > + *          |________|________|________|________|________|
> > + *                            |
> > + *                    Aligned addresses
> > + *
> > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
> > + * Expect the counter to not be updated.
> > + */
> > +static int memblock_trim_memory_unaligned_base_check(void)
> > +{
> > +	struct memblock_region *rgn1, *rgn2;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +	phys_addr_t offset = SZ_2;
> > +	phys_addr_t r2_base, r2_size;
> > +
> > +	rgn1 = &memblock.memory.regions[0];
> > +	rgn2 = &memblock.memory.regions[1];
> > +
> > +	struct region r1 = {
> > +		.base = alignment,
> > +		.size = alignment * 2
> > +	};
> > +	struct region r2 = {
> > +		.base = alignment * 4 + offset,
> > +		.size = alignment * 2 - offset
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	r2_base = r2.base + (alignment - offset);
> > +	r2_size = r2.size - (alignment - offset);
> 
> Also the variable name.
> 
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r1.base, r1.size);
> > +	memblock_add(r2.base, r2.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	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_EQ(memblock.memory.cnt, 2);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +/*
> > + * A test that tries to trim memory when there are two available regions, r1 and
> > + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
> > + * and unaligned at the end:
> > + *
> > + *                                             Unaligned address
> > + *                                                     |
> > + *                                                     v
> > + * |        +-----------------+        +---------------+   |
> > + * |        |        r1       |        |      r2       |   |
> > + * +--------+-----------------+--------+---------------+---+
> > + *          ^        ^        ^        ^        ^        ^
> > + *          |________|________|________|________|________|
> > + *                            |
> > + *                    Aligned addresses
> > + *
> > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
> 								^
> 							at the end.

I forgot to make this change in v2. I will include it in v3.

> > + * Expect the counter to not be updated.
> > + */
> > +static int memblock_trim_memory_unaligned_end_check(void)
> > +{
> > +	struct memblock_region *rgn1, *rgn2;
> > +	phys_addr_t alignment = SMP_CACHE_BYTES;
> > +	phys_addr_t offset = SZ_2;
> > +	phys_addr_t r2_size;
> > +
> > +	rgn1 = &memblock.memory.regions[0];
> > +	rgn2 = &memblock.memory.regions[1];
> > +
> > +	struct region r1 = {
> > +		.base = alignment,
> > +		.size = alignment * 2
> > +	};
> > +	struct region r2 = {
> > +		.base = alignment * 4,
> > +		.size = alignment * 2 - offset
> > +	};
> > +
> > +	PREFIX_PUSH();
> > +
> > +	r2_size = r2.size - (alignment - offset);
> > +
> > +	reset_memblock_regions();
> > +	memblock_add(r1.base, r1.size);
> > +	memblock_add(r2.base, r2.size);
> > +	memblock_trim_memory(alignment);
> > +
> > +	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_EQ(memblock.memory.cnt, 2);
> > +
> > +	test_pass_pop();
> > +
> > +	return 0;
> > +}
> > +
> > +static int memblock_trim_memory_checks(void)
> > +{
> > +	prefix_reset();
> > +	prefix_push(FUNC_TRIM);
> > +	test_print("Running %s tests...\n", FUNC_TRIM);
> > +
> > +	memblock_trim_memory_aligned_check();
> > +	memblock_trim_memory_too_small_check();
> > +	memblock_trim_memory_unaligned_base_check();
> > +	memblock_trim_memory_unaligned_end_check();
> > +
> > +	prefix_pop();
> > +
> > +	return 0;
> > +}
> > +
> >   int memblock_basic_checks(void)
> >   {
> >   	memblock_initialization_check();
> > @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void)
> >   	memblock_remove_checks();
> >   	memblock_free_checks();
> >   	memblock_bottom_up_checks();
> > +	memblock_trim_memory_checks();
> >   	return 0;
> >   }
> 
> Others looks good.

Thanks,
Rebecca