Skip to content

Commit 13ca0ff

Browse files
automas-devautomas-dev
committed
100% coverage ov memory_alloc, re-write memory_alloc tests
1 parent fa85199 commit 13ca0ff

File tree

2 files changed

+77
-89
lines changed

2 files changed

+77
-89
lines changed

‎src/memory_alloc/src/memory_alloc.c‎

Lines changed: 1 addition & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -196,8 +196,6 @@ int memory_free(memory_t * mem, void * ptr) {
196196
* @param size minimum number of bytes
197197
*/
198198
static void memory_split_entry(memory_t * mem, memory_entry_t * entry, size_t size) {
199-
ALIGN_SIZE(size);
200-
201199
memory_entry_t * new_entry = ENTRY_PTR(entry) + size;
202200

203201
new_entry->magic = MAGIC_FREE;
@@ -263,18 +261,7 @@ static memory_entry_t * memory_find_entry_size(memory_t * mem, size_t size) {
263261
break;
264262
}
265263

266-
memory_entry_t * next_entry = entry->next;
267-
268-
if (next_entry == mem->last) {
269-
mem->last = entry;
270-
}
271-
272-
entry->size += next_entry->size + sizeof(memory_entry_t);
273-
entry->next = next_entry->next;
274-
275-
if (next_entry->next) {
276-
next_entry->next->prev = entry;
277-
}
264+
memory_merge_with_next(mem, entry);
278265

279266
if (entry->size >= size) {
280267
break;

‎tests/src/memory_alloc/test_memory_alloc.cpp‎

Lines changed: 76 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -57,9 +57,7 @@ class MemoryAlloc : public ::testing::Test {
5757
mem.last = entry_3;
5858
mem.alloc_pages_fn = alloc_page;
5959

60-
ASSERT_EQ(pages.data(), (void *)entry_1);
61-
SCOPED_TRACE("SetUp");
62-
expect_memory_joined();
60+
alloc_page_fake.return_val = pages.data() + PAGE_SIZE * 3;
6361
}
6462

6563
void expect_memory_joined() {
@@ -69,16 +67,18 @@ class MemoryAlloc : public ::testing::Test {
6967

7068
while (entry->next) {
7169
memory_entry_t * expect_next = (memory_entry_t *)((uint32_t)entry + entry->size + sizeof(memory_entry_t));
72-
EXPECT_EQ(expect_next, entry->next) << "Entry " << i;
70+
ASSERT_EQ(expect_next, entry->next) << "Entry " << i;
7371

7472
i++;
7573
entry = entry->next;
7674
}
7775

78-
EXPECT_EQ(mem.last, entry);
76+
ASSERT_EQ(mem.last, entry);
7977
}
8078
};
8179

80+
#define ASSERT_MEMORY_JOINED() ASSERT_NO_FATAL_FAILURE(expect_memory_joined())
81+
8282
TEST_F(MemoryAlloc, memory_init) {
8383
EXPECT_NE(0, memory_init(&mem, 0));
8484
EXPECT_NE(0, memory_init(0, alloc_page));
@@ -104,109 +104,110 @@ TEST_F(MemoryAlloc, memory_init) {
104104
EXPECT_EQ(nullptr, entry_1->prev);
105105
}
106106

107-
TEST_F(MemoryAlloc, memory_alloc_Success) {
107+
TEST_F(MemoryAlloc, memory_alloc_InvalidParameters) {
108108
EXPECT_EQ(nullptr, memory_alloc(&mem, 0));
109109
EXPECT_EQ(nullptr, memory_alloc(0, 1));
110+
}
110111

111-
// No size change
112-
EXPECT_EQ(ENTRY_PTR(entry_1), memory_alloc(&mem, PAGE_SIZE - sizeof(memory_entry_t)));
112+
TEST_F(MemoryAlloc, memory_alloc_FoundEntry) {
113+
void * ptr = memory_alloc(&mem, 1);
114+
EXPECT_EQ(ENTRY_PTR(entry_1), ptr);
113115
EXPECT_EQ(MAGIC_USED, entry_1->magic);
114-
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t), entry_1->size);
116+
EXPECT_EQ(4, entry_1->size);
117+
ASSERT_MEMORY_JOINED();
118+
}
115119

116-
EXPECT_EQ(ENTRY_PTR(entry_2), memory_alloc(&mem, PAGE_SIZE - sizeof(memory_entry_t)));
120+
TEST_F(MemoryAlloc, memory_alloc_FirstUsed) {
121+
entry_1->magic = MAGIC_USED;
122+
123+
void * ptr = memory_alloc(&mem, PAGE_SIZE - sizeof(memory_entry_t));
124+
EXPECT_EQ(ENTRY_PTR(entry_2), ptr);
117125
EXPECT_EQ(MAGIC_USED, entry_2->magic);
118126
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t), entry_2->size);
127+
ASSERT_MEMORY_JOINED();
119128
}
120129

121-
TEST_F(MemoryAlloc, memory_alloc_SmallerThanFreeEntry) {
122-
EXPECT_EQ(ENTRY_PTR(entry_1), memory_alloc(&mem, 1));
130+
TEST_F(MemoryAlloc, memory_alloc_FirstFoundTooSmall) {
131+
void * ptr = memory_alloc(&mem, PAGE_SIZE);
132+
EXPECT_EQ(ENTRY_PTR(entry_1), ptr);
123133
EXPECT_EQ(MAGIC_USED, entry_1->magic);
124-
EXPECT_EQ(4, entry_1->size);
134+
EXPECT_EQ(PAGE_SIZE, entry_1->size);
135+
ASSERT_MEMORY_JOINED();
136+
}
137+
138+
TEST_F(MemoryAlloc, memory_alloc_FirstFoundTooSmall_CantMerge) {
139+
entry_2->magic = MAGIC_USED;
125140

126-
EXPECT_NE(nullptr, entry_1->next);
127-
EXPECT_NE(entry_2, entry_1->next);
141+
void * ptr = memory_alloc(&mem, PAGE_SIZE);
142+
EXPECT_EQ(ENTRY_PTR(entry_3), ptr);
143+
EXPECT_EQ(MAGIC_USED, entry_3->magic);
144+
EXPECT_EQ(PAGE_SIZE, entry_3->size);
145+
EXPECT_EQ(MAGIC_FREE, entry_1->magic);
146+
EXPECT_EQ(1, alloc_page_fake.call_count);
147+
ASSERT_MEMORY_JOINED();
148+
}
128149

129-
memory_entry_t * entry_1_5 = entry_1->next;
130-
EXPECT_EQ(MAGIC_FREE, entry_1_5->magic);
131-
EXPECT_EQ(entry_2, entry_1_5->next);
132-
EXPECT_EQ(entry_1, entry_1_5->prev);
133-
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t) * 2 - 4, entry_1_5->size);
134-
expect_memory_joined();
150+
TEST_F(MemoryAlloc, memory_alloc_MergeWithLast) {
151+
entry_1->magic = MAGIC_USED;
152+
153+
void * ptr = memory_alloc(&mem, PAGE_SIZE);
154+
EXPECT_EQ(ENTRY_PTR(entry_2), ptr);
155+
EXPECT_EQ(MAGIC_USED, entry_2->magic);
156+
EXPECT_EQ(PAGE_SIZE, entry_2->size);
157+
ASSERT_MEMORY_JOINED();
135158
}
136159

137-
TEST_F(MemoryAlloc, memory_alloc_LargerThanFreeEntry_Combine) {
138-
EXPECT_EQ(ENTRY_PTR(entry_1), memory_alloc(&mem, PAGE_SIZE));
139-
EXPECT_EQ(MAGIC_USED, entry_1->magic);
140-
EXPECT_EQ(PAGE_SIZE, entry_1->size);
160+
TEST_F(MemoryAlloc, memory_alloc_MergeAll) {
141161

142-
memory_entry_t * entry_1_5 = entry_1->next;
143-
EXPECT_EQ(MAGIC_FREE, entry_1_5->magic);
144-
EXPECT_EQ(entry_3, entry_1_5->next);
145-
EXPECT_EQ(entry_1, entry_1_5->prev);
146-
EXPECT_EQ(entry_1_5, entry_3->prev);
147-
EXPECT_EQ(entry_1_5, entry_1->next);
148-
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t) * 2, entry_1_5->size);
149-
expect_memory_joined();
162+
void * ptr = memory_alloc(&mem, PAGE_SIZE * 3 - sizeof(memory_entry_t));
163+
EXPECT_EQ(ENTRY_PTR(entry_1), ptr);
164+
EXPECT_EQ(MAGIC_USED, entry_1->magic);
165+
EXPECT_EQ(PAGE_SIZE * 3 - sizeof(memory_entry_t), entry_1->size);
166+
EXPECT_EQ(nullptr, entry_1->next);
167+
EXPECT_EQ(entry_1, mem.last);
168+
EXPECT_EQ(0, alloc_page_fake.call_count);
169+
ASSERT_MEMORY_JOINED();
150170
}
151171

152-
TEST_F(MemoryAlloc, memory_alloc_NeedMore_LastFree) {
172+
TEST_F(MemoryAlloc, memory_alloc_AllocPage_SizeAligned) {
153173
entry_1->magic = MAGIC_USED;
154174
entry_2->magic = MAGIC_USED;
175+
entry_3->magic = MAGIC_USED;
155176

156-
alloc_page_fake.return_val = 0;
177+
memory_entry_t * entry_4 = (memory_entry_t *)(pages.data() + PAGE_SIZE * 3);
157178

158-
// Needs more memory but fails (last entry free)
159-
EXPECT_EQ(nullptr, memory_alloc(&mem, PAGE_SIZE));
179+
void * ptr = memory_alloc(&mem, PAGE_SIZE - sizeof(memory_entry_t));
180+
EXPECT_EQ(ENTRY_PTR(entry_4), ptr);
181+
EXPECT_EQ(MAGIC_USED, entry_4->magic);
182+
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t), entry_4->size);
183+
EXPECT_EQ(1, alloc_page_fake.call_count);
184+
EXPECT_EQ(1, alloc_page_fake.arg0_val);
185+
ASSERT_MEMORY_JOINED();
186+
}
160187

161-
alloc_page_fake.return_val = pages.data() + PAGE_SIZE * 3;
188+
TEST_F(MemoryAlloc, memory_alloc_AllocPage_LastFree) {
189+
entry_1->magic = MAGIC_USED;
190+
entry_2->magic = MAGIC_USED;
162191

163-
// Needs more memory (last entry free)
164-
EXPECT_EQ(ENTRY_PTR(entry_3), memory_alloc(&mem, PAGE_SIZE));
192+
void * ptr = memory_alloc(&mem, PAGE_SIZE);
193+
EXPECT_EQ(ENTRY_PTR(entry_3), ptr);
194+
EXPECT_EQ(MAGIC_USED, entry_3->magic);
165195
EXPECT_EQ(PAGE_SIZE, entry_3->size);
166-
EXPECT_EQ(2, alloc_page_fake.call_count);
196+
EXPECT_EQ(1, alloc_page_fake.call_count);
167197
EXPECT_EQ(1, alloc_page_fake.arg0_val);
168-
169-
memory_entry_t * entry_4 = entry_3->next;
170-
171-
EXPECT_EQ(entry_4, mem.last);
172-
EXPECT_EQ(entry_3, entry_4->prev);
173-
EXPECT_EQ(entry_4, entry_3->next);
174-
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t) * 2, entry_4->size);
175-
expect_memory_joined();
198+
ASSERT_MEMORY_JOINED();
176199
}
177200

178-
TEST_F(MemoryAlloc, memory_alloc_NeedMore_LastUsed) {
201+
TEST_F(MemoryAlloc, memory_alloc_AllocPage_AllocPageFails) {
179202
entry_1->magic = MAGIC_USED;
180203
entry_2->magic = MAGIC_USED;
181204
entry_3->magic = MAGIC_USED;
182205

183206
alloc_page_fake.return_val = 0;
184207

185-
// Needs more memory but fails (last entry used)
186-
EXPECT_EQ(nullptr, memory_alloc(&mem, PAGE_SIZE));
187-
188-
alloc_page_fake.return_val = pages.data() + PAGE_SIZE * 3;
189-
190-
memory_entry_t * entry_4 = (memory_entry_t *)(pages.data() + PAGE_SIZE * 3);
191-
192-
// Needs more memory (last entry used)
193-
EXPECT_EQ(ENTRY_PTR(entry_4), memory_alloc(&mem, PAGE_SIZE));
194-
EXPECT_EQ(2, alloc_page_fake.call_count);
195-
EXPECT_EQ(2, alloc_page_fake.arg0_val);
196-
197-
EXPECT_EQ(MAGIC_USED, entry_4->magic);
198-
EXPECT_EQ(PAGE_SIZE, entry_4->size);
199-
EXPECT_EQ(entry_3, entry_4->prev);
200-
EXPECT_EQ(entry_4, entry_3->next);
201-
202-
memory_entry_t * entry_5 = entry_4->next;
203-
204-
EXPECT_EQ(MAGIC_FREE, entry_5->magic);
205-
EXPECT_EQ(PAGE_SIZE - sizeof(memory_entry_t) * 2, entry_5->size);
206-
EXPECT_EQ(entry_4, entry_5->prev);
207-
EXPECT_EQ(nullptr, entry_5->next);
208-
EXPECT_EQ(entry_5, mem.last);
209-
expect_memory_joined();
208+
// Keep as 1 to test size not aligned to 4 bytes
209+
EXPECT_EQ(nullptr, memory_alloc(&mem, 1));
210+
ASSERT_MEMORY_JOINED();
210211
}
211212

212213
TEST_F(MemoryAlloc, memory_realloc) {

0 commit comments

Comments
 (0)