1

Author: code1009

cc/cc/cc/allocator/cc_simple_segregated_storage_dump.c

@@ -79,11 +79,12 @@ cc_api void cc_simple_segregated_storage_dump(cc_simple_segregated_storage_t* si
 
 
 		printf(
-			"- free_chunk [%3lld]   = %p(%4lld): index=%3lld, next_free_chunk = %3lld : %p(%4lld)\n",
+			"- free_chunk [%3lld]   = %p(%4lld)[%3lld] : next_free_chunk = %p(%4lld)[%3lld] \n",
 			(int64_t)free_chunk_count,
-			(void*)free_chunk, cc_offset_address(free_chunk, base_address), 
-			(int64_t)free_chunk_index, (int64_t)free_chunk_next_index,
-			(void*)free_chunk->next_free_chunk, cc_offset_address(free_chunk->next_free_chunk, base_address)
+			(void*)free_chunk, cc_offset_address(free_chunk, base_address),
+			(int64_t)free_chunk_index,
+			(void*)free_chunk->next_free_chunk, cc_offset_address(free_chunk->next_free_chunk, base_address),
+			(int64_t)free_chunk_next_index
 			);
 
 		free_chunk_count++;

cc/cc/cc/dynamic/cc_first_fit_dump.c

@@ -108,13 +108,13 @@ cc_api void cc_first_fit_dump(cc_first_fit_t* first_fit, size_t number, uintptr_
 
 
 		printf(
-			"- block[%3lld]         = %p(%4lld): pointer = %p(%4lld) size = %6lld bytes %s \n",
+			"- block[%3lld]         = %p(%4lld) size = %6lld bytes : pointer = %p(%4lld) %s \n",
 			(int64_t)block_count,
 			(void*)block, cc_offset_address(block, base_address),
-			(void*)(address), cc_offset_address((void*)(address), base_address),
 			(int64_t)block_size,
+			(void*)(address), cc_offset_address((void*)(address), base_address),
 			(block_is_allocated ? "allocated" : "free     ")
-		);
+			);
 
 
 		block = (cc_first_fit_block_head_t*)(block_address + block_size);

cc/cc/test_cc/test_case_cc_string_1.cpp

@@ -8,6 +8,16 @@
 
 /////////////////////////////////////////////////////////////////////////////
 //===========================================================================
+static inline size_t cc_string_allocated_size(cc_string_t* s)
+{
+	size_t current = 1;
+
+	
+	while (current < (s->capacity))
+		current <<= 1;
+	return current;
+}
+
 static void string_append(bool memory_leack)
 {
 	test_out
@@ -17,15 +27,17 @@ static void string_append(bool memory_leack)
 
 
 	cc_string_t s;
+	cc_string_t s0;
+	cc_string_t s1;
+
+
 	cc_string_create(&s, cc_default_string_heap_memory_allocator());
 	cc_string_append(&s, "Hello");
 
 
 
-	cc_string_t s0;
 	cc_string_create(&s0, cc_default_string_heap_memory_allocator());
 
-	cc_string_t s1;
 	cc_string_create(&s1, cc_default_string_heap_memory_allocator());
 	cc_string_append(&s1, "<Hello");
 	cc_string_append(&s1, "World>");
@@ -35,7 +47,7 @@ static void string_append(bool memory_leack)
 	cc_string_append(&s1, "<World>");
 
 
-	for (size_t i = 0; i < 10; i++)
+	for (size_t i = 0; i < 20; i++)
 	{
 		cc_string_append(&s0, cc_string_c_str(&s1));
 		test_out
@@ -46,15 +58,45 @@ static void string_append(bool memory_leack)
 			;
 	}
 
+
 	if (memory_leack == false)
 	{
 		cc_string_destroy(&s1);
 	}
+	else
+	{
+		test_out << "Memory Leak Test: Skip cc_string_destroy(&s1)" << test_tendl;
+	}
 
 	test_out << "s0: data=" << cc_string_c_str(&s0) << test_tendl;
 
 
 
+	if (memory_leack == false)
+	{
+		cc_string_destroy(&s0);
+	}
+	else
+	{
+		size_t alignment = sizeof(void*) * 2;
+		size_t s0_string_memory_size = s0.capacity + 1;
+		size_t s0_string_memory_aligned_size =
+			s0_string_memory_size / alignment * alignment + ((s0_string_memory_size % alignment) ? alignment : 0);
+
+		size_t s0_memory_leak_size =
+			sizeof(cc_first_fit_block_head_t) +
+			s0_string_memory_aligned_size;
+			;
+
+		uintptr_t s0_address = (uintptr_t)&s0.data[0];
+
+		test_out << "Memory Leak Test: Skip cc_string_destroy(&s0):"
+			<< " s0_memory_leak_size=" << s0_memory_leak_size
+			<< " s0.data =" << (void*)s0_address
+			<< test_tendl;
+	}
+
+
 	if (memory_leack == false)
 	{
 		cc_string_destroy(&s);