iris/kaizen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge commit '352a52804df5b9f475d19d3fa8f567c1bf98b8ac' as 'external/capstone'

Browse Source
This commit is contained in:
SimoneN64
2024-09-23 19:06:48 +02:00
parent d3df933ca2 352a52804d
commit d3096609fe
3915 changed files with 2927938 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
external/capstone/tests/unit/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,12 @@
cmake_minimum_required(VERSION 3.15)
enable_testing()
set(UNIT_TEST_SOURCES sstream.c utils.c)
include_directories(include)
foreach(TSRC ${UNIT_TEST_SOURCES})
string(REGEX REPLACE ".c$" "" TBIN ${TSRC})
add_executable(${TBIN} "${TESTS_UNIT_DIR}/${TSRC}")
target_link_libraries(${TBIN} PRIVATE capstone)
add_test(NAME "unit_${TBIN}" COMMAND ${TBIN})
endforeach()

2
external/capstone/tests/unit/README.md vendored Normal file
View File

@@ -0,0 +1,2 @@
Nothing in here yet :(

44
external/capstone/tests/unit/include/unit_test.h vendored Normal file
View File

@@ -0,0 +1,44 @@
// Copyright © 2024 Rot127 <unisono@quyllur.org>
// SPDX-License-Identifier: BSD-3
#define CHECK_OS_EQUAL_RET_FALSE(OS, str) \
do { \
if (strcmp(OS.buffer, str) != 0) { \
printf("OS.buffer != str\n"); \
printf("OS.buffer: %s\n", OS.buffer); \
printf("str : %s\n", str); \
return false; \
} \
} while (0);
#define CHECK_STR_EQUAL_RET_FALSE(a, b) \
do { \
if (strcmp(a, b) != 0) { \
printf("%s != %s\n", a, b); \
return false; \
} \
} while (0);
#define CHECK_NULL_RET_FALSE(ptr) \
do { \
if (ptr != NULL) { \
printf(#ptr " is not NULL\n"); \
return false; \
} \
} while (0);
#define CHECK_PTR_EQUAL_RET_FALSE(a, b) \
do { \
if (a != b) { \
printf("%p != %p\n", a, b); \
return false; \
} \
} while (0);
#define CHECK_INT_EQUAL_RET_FALSE(a, b) \
do { \
if (a != b) { \
printf("%" PRId32 " != %" PRId32 "\n", a, b); \
return false; \
} \
} while (0);

534
external/capstone/tests/unit/sstream.c vendored Normal file
View File

@@ -0,0 +1,534 @@
// Copyright © 2024 Rot127 <unisono@quyllur.org>
// SPDX-License-Identifier: BSD-3
#include "unit_test.h"
#include "../SStream.h"
#include "../utils.h"
#include <stdio.h>
#include <string.h>
static void overflow_SStream_concat0(SStream *OS, bool *returned_in_time)
{
char buf[SSTREAM_BUF_LEN + 1] = { 0 };
memset(&buf, 'A', SSTREAM_BUF_LEN);
SStream_concat0(OS, buf);
*returned_in_time = OS->buffer[SSTREAM_BUF_LEN - 1] == '\0';
}
static void overflow_SStream_concat(SStream *OS, bool *returned_in_time)
{
char buf[SSTREAM_BUF_LEN + 1] = { 0 };
memset(&buf, 'A', SSTREAM_BUF_LEN);
SStream_concat(OS, "%s", buf);
*returned_in_time = OS->buffer[SSTREAM_BUF_LEN - 1] == '\0';
}
static void overflow_SStream_concat1(SStream *OS, bool *returned_in_time)
{
char buf[SSTREAM_BUF_LEN] = { 0 };
memset(&buf, 'A', SSTREAM_BUF_LEN - 1);
SStream_concat0(OS, buf);
// Should return here because null byte is overflown.
SStream_concat1(OS, 'A');
*returned_in_time = OS->buffer[SSTREAM_BUF_LEN - 1] == '\0';
}
static bool test_overflow_check()
{
printf("Test test_overflow_check\n");
SStream OS = { 0 };
SStream_Init(&OS);
bool returned_in_time = true;
overflow_SStream_concat0(&OS, &returned_in_time);
if (!returned_in_time) {
printf("Failed overflow_SStream_concat0\n");
return false;
}
overflow_SStream_concat(&OS, &returned_in_time);
if (!returned_in_time) {
printf("Failed overflow_SStream_concat\n");
return false;
}
overflow_SStream_concat1(&OS, &returned_in_time);
if (!returned_in_time) {
printf("Failed overflow_SStream_concat1\n");
return false;
}
return true;
}
static bool test_markup_os()
{
printf("Test test_markup_os\n");
SStream OS = { 0 };
SStream_Init(&OS);
SStream_concat0(&OS, "0");
CHECK_OS_EQUAL_RET_FALSE(OS, "0");
OS.markup_stream = true;
printUInt64(&OS, 0);
CHECK_OS_EQUAL_RET_FALSE(OS, "00");
markup_OS(&OS, Markup_Immediate);
printUInt64(&OS, 0);
CHECK_OS_EQUAL_RET_FALSE(OS, "00<imm:0>");
markup_OS(&OS, Markup_Memory);
printUInt32(&OS, 0);
CHECK_OS_EQUAL_RET_FALSE(OS, "00<imm:0><mem:0>");
markup_OS(&OS, Markup_Target);
printUInt32(&OS, 0);
CHECK_OS_EQUAL_RET_FALSE(OS, "00<imm:0><mem:0><tar:0>");
markup_OS(&OS, Markup_Register);
SStream_concat0(&OS, "r19");
CHECK_OS_EQUAL_RET_FALSE(OS, "00<imm:0><mem:0><tar:0><reg:r19>");
return true;
}
bool test_printint8()
{
printf("Test test_printint8\n");
SStream OS = { 0 };
SStream_Init(&OS);
printInt8(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "0xa");
SStream_Flush(&OS, NULL);
printInt8(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "9");
SStream_Flush(&OS, NULL);
printInt8(&OS, -(HEX_THRESHOLD + 1));
CHECK_OS_EQUAL_RET_FALSE(OS, "-0xa");
SStream_Flush(&OS, NULL);
printInt8(&OS, -HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "-9");
SStream_Flush(&OS, NULL);
printInt8(&OS, INT8_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "0x7f");
SStream_Flush(&OS, NULL);
printInt8(&OS, INT8_MIN);
CHECK_OS_EQUAL_RET_FALSE(OS, "-0x80");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printint16()
{
printf("Test test_printint16\n");
SStream OS = { 0 };
SStream_Init(&OS);
printInt16(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "0xa");
SStream_Flush(&OS, NULL);
printInt16(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "9");
SStream_Flush(&OS, NULL);
printInt16(&OS, -(HEX_THRESHOLD + 1));
CHECK_OS_EQUAL_RET_FALSE(OS, "-0xa");
SStream_Flush(&OS, NULL);
printInt16(&OS, -HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "-9");
SStream_Flush(&OS, NULL);
printInt16(&OS, INT16_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "0x7fff");
SStream_Flush(&OS, NULL);
printInt16(&OS, INT16_MIN);
CHECK_OS_EQUAL_RET_FALSE(OS, "-0x8000");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printint32()
{
printf("Test test_printint32\n");
SStream OS = { 0 };
SStream_Init(&OS);
printInt32(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "0xa");
SStream_Flush(&OS, NULL);
printInt32(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "9");
SStream_Flush(&OS, NULL);
printInt32(&OS, -(HEX_THRESHOLD + 1));
CHECK_OS_EQUAL_RET_FALSE(OS, "-0xa");
SStream_Flush(&OS, NULL);
printInt32(&OS, -HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "-9");
SStream_Flush(&OS, NULL);
printInt32(&OS, INT32_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "0x7fffffff");
SStream_Flush(&OS, NULL);
printInt32(&OS, INT32_MIN);
CHECK_OS_EQUAL_RET_FALSE(OS, "-0x80000000");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printint64()
{
printf("Test test_printint64\n");
SStream OS = { 0 };
SStream_Init(&OS);
printInt64(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "0xa");
SStream_Flush(&OS, NULL);
printInt64(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "9");
SStream_Flush(&OS, NULL);
printInt64(&OS, -(HEX_THRESHOLD + 1));
CHECK_OS_EQUAL_RET_FALSE(OS, "-0xa");
SStream_Flush(&OS, NULL);
printInt64(&OS, -HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "-9");
SStream_Flush(&OS, NULL);
printInt64(&OS, INT64_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "0x7fffffffffffffff");
SStream_Flush(&OS, NULL);
printInt64(&OS, INT64_MIN);
CHECK_OS_EQUAL_RET_FALSE(OS, "-0x8000000000000000");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printint32_bang()
{
printf("Test test_printint32Bang\n");
SStream OS = { 0 };
SStream_Init(&OS);
printInt32Bang(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0xa");
SStream_Flush(&OS, NULL);
printInt32Bang(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "#9");
SStream_Flush(&OS, NULL);
printInt32Bang(&OS, -(HEX_THRESHOLD + 1));
CHECK_OS_EQUAL_RET_FALSE(OS, "#-0xa");
SStream_Flush(&OS, NULL);
printInt32Bang(&OS, -HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "#-9");
SStream_Flush(&OS, NULL);
printInt32Bang(&OS, INT32_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0x7fffffff");
SStream_Flush(&OS, NULL);
printInt32Bang(&OS, INT32_MIN);
CHECK_OS_EQUAL_RET_FALSE(OS, "#-0x80000000");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printint64_bang()
{
printf("Test test_printint64Bang\n");
SStream OS = { 0 };
SStream_Init(&OS);
printInt64Bang(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0xa");
SStream_Flush(&OS, NULL);
printInt64Bang(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "#9");
SStream_Flush(&OS, NULL);
printInt64Bang(&OS, -(HEX_THRESHOLD + 1));
CHECK_OS_EQUAL_RET_FALSE(OS, "#-0xa");
SStream_Flush(&OS, NULL);
printInt64Bang(&OS, -HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "#-9");
SStream_Flush(&OS, NULL);
printInt64Bang(&OS, INT64_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0x7fffffffffffffff");
SStream_Flush(&OS, NULL);
printInt64Bang(&OS, INT64_MIN);
CHECK_OS_EQUAL_RET_FALSE(OS, "#-0x8000000000000000");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printuint32_bang()
{
printf("Test test_printuint32Bang\n");
SStream OS = { 0 };
SStream_Init(&OS);
printUInt32Bang(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0xa");
SStream_Flush(&OS, NULL);
printUInt32Bang(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "#9");
SStream_Flush(&OS, NULL);
printUInt32Bang(&OS, UINT32_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0xffffffff");
SStream_Flush(&OS, NULL);
return true;
}
bool test_printuint64_bang()
{
printf("Test test_printuint64Bang\n");
SStream OS = { 0 };
SStream_Init(&OS);
printUInt64Bang(&OS, HEX_THRESHOLD + 1);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0xa");
SStream_Flush(&OS, NULL);
printUInt64Bang(&OS, HEX_THRESHOLD);
CHECK_OS_EQUAL_RET_FALSE(OS, "#9");
SStream_Flush(&OS, NULL);
printUInt64Bang(&OS, UINT64_MAX);
CHECK_OS_EQUAL_RET_FALSE(OS, "#0xffffffffffffffff");
SStream_Flush(&OS, NULL);
return true;
}
bool test_trimls() {
printf("Test test_replc\n");
SStream OS = { 0 };
SStream_Init(&OS);
SStream_concat0(&OS, "AAA");
SStream_trimls(&OS);
CHECK_OS_EQUAL_RET_FALSE(OS, "AAA");
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, "\t AAA");
SStream_trimls(&OS);
CHECK_OS_EQUAL_RET_FALSE(OS, "AAA");
// Don't remove middle tabs and spaces
SStream_concat0(&OS, "\t AAA");
SStream_trimls(&OS);
CHECK_OS_EQUAL_RET_FALSE(OS, "AAA\t AAA");
SStream_Flush(&OS, NULL);
// Test do nothing
SStream_trimls(&OS);
CHECK_OS_EQUAL_RET_FALSE(OS, "");
// Everywhere tabs
char cmp_buf[SSTREAM_BUF_LEN] = { 0 };
memset(cmp_buf, '\t', sizeof(cmp_buf) - 1);
SStream_trimls(&OS);
CHECK_OS_EQUAL_RET_FALSE(OS, "");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 0);
return true;
}
bool test_copy_mnem_opstr() {
printf("Test test_copy_mnem_opstr\n");
SStream OS = { 0 };
SStream_Init(&OS);
SStream_concat0(&OS, "AAA\tBBBB");
char mnem_1[1] = { 0 };
char opstr_1[1] = { 0 };
SStream_extract_mnem_opstr(&OS, mnem_1, sizeof(mnem_1), opstr_1, sizeof(opstr_1));
CHECK_STR_EQUAL_RET_FALSE(mnem_1, "");
CHECK_STR_EQUAL_RET_FALSE(opstr_1, "");
char mnem_3[3] = { 0 };
char opstr_3[3] = { 0 };
SStream_extract_mnem_opstr(&OS, mnem_3, sizeof(mnem_3), opstr_3, sizeof(opstr_3));
CHECK_STR_EQUAL_RET_FALSE(mnem_3, "AA");
CHECK_STR_EQUAL_RET_FALSE(opstr_3, "BB");
char mnem_4[4] = { 0 };
char opstr_4[4] = { 0 };
SStream_extract_mnem_opstr(&OS, mnem_4, sizeof(mnem_4), opstr_4, sizeof(opstr_4));
CHECK_STR_EQUAL_RET_FALSE(mnem_4, "AAA");
CHECK_STR_EQUAL_RET_FALSE(opstr_4, "BBB");
char mnem_5[5] = { 0 };
char opstr_5[5] = { 0 };
SStream_extract_mnem_opstr(&OS, mnem_5, sizeof(mnem_5), opstr_5, sizeof(opstr_5));
CHECK_STR_EQUAL_RET_FALSE(mnem_5, "AAA");
CHECK_STR_EQUAL_RET_FALSE(opstr_5, "BBBB");
// No mnemonic
char mnem_9[9] = { 0 };
char opstr_9[9] = { 0 };
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, " AAA\tBBBB");
SStream_extract_mnem_opstr(&OS, mnem_9, sizeof(mnem_9), opstr_9, sizeof(opstr_9));
CHECK_STR_EQUAL_RET_FALSE(mnem_9, "");
CHECK_STR_EQUAL_RET_FALSE(opstr_9, "AAA\tBBBB");
// No opstr
char mnem_6[6] = { 0 };
char opstr_6[6] = { 0 };
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, "AAA \t");
SStream_extract_mnem_opstr(&OS, mnem_6, sizeof(mnem_6), opstr_6, sizeof(opstr_6));
CHECK_STR_EQUAL_RET_FALSE(mnem_6, "AAA");
CHECK_STR_EQUAL_RET_FALSE(opstr_6, "");
return true;
}
bool test_replc()
{
printf("Test test_replc\n");
SStream OS = { 0 };
SStream_Init(&OS);
char cmp_buf[SSTREAM_BUF_LEN] = { 0 };
memset(cmp_buf, 'A', sizeof(cmp_buf) - 1);
cmp_buf[100] = 'C';
SStream_concat0(&OS, cmp_buf);
cmp_buf[0] = 'B';
const char *next = SStream_replc(&OS, 'A', 'B');
CHECK_PTR_EQUAL_RET_FALSE(SStream_rbuf(&OS) + 1, next);
CHECK_OS_EQUAL_RET_FALSE(OS, cmp_buf);
cmp_buf[1] = 'B';
next = SStream_replc(&OS, 'A', 'B');
CHECK_PTR_EQUAL_RET_FALSE(SStream_rbuf(&OS) + 2, next);
CHECK_OS_EQUAL_RET_FALSE(OS, cmp_buf);
cmp_buf[100] = 'A'; // Replace the C from before
next = SStream_replc(&OS, 'C', 'A');
CHECK_PTR_EQUAL_RET_FALSE(SStream_rbuf(&OS) + 101, next);
CHECK_OS_EQUAL_RET_FALSE(OS, cmp_buf);
// X doesn't exist
next = SStream_replc(&OS, 'X', 'A');
CHECK_NULL_RET_FALSE(next);
// Replacing \0 byte is forbidden.
next = SStream_replc(&OS, '\0', 'A');
CHECK_NULL_RET_FALSE(next);
// But replacing any \0 byte is allowed.
SStream_Flush(&OS, NULL);
next = SStream_replc(&OS, '\0', 'A');
CHECK_PTR_EQUAL_RET_FALSE(SStream_rbuf(&OS) + 1, next);
CHECK_OS_EQUAL_RET_FALSE(OS, "A");
return true;
}
bool test_replc_str()
{
printf("Test test_replc_str\n");
SStream OS = { 0 };
SStream_Init(&OS);
SStream_replc_str(&OS, 'A', "REPLACED");
CHECK_OS_EQUAL_RET_FALSE(OS, "");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 0);
SStream_replc_str(&OS, '\0', "REPLACED");
CHECK_OS_EQUAL_RET_FALSE(OS, "REPLACED");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 8);
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, "\tA--X");
SStream_replc_str(&OS, 'A', "REPLACED");
CHECK_OS_EQUAL_RET_FALSE(OS, "\tREPLACED--X");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 12);
SStream_replc_str(&OS, 'X', "REPLACED");
CHECK_OS_EQUAL_RET_FALSE(OS, "\tREPLACED--REPLACED");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 19);
/// Too big strings are ignored.
char repl[SSTREAM_BUF_LEN] = { 0 };
memset(repl, 'A', sizeof(repl) - 1);
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, "\tA--");
SStream_replc_str(&OS, 'A', repl);
CHECK_OS_EQUAL_RET_FALSE(OS, "\tA--");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 4);
/// Last null byte is not replaced.
memset(repl, 'A', sizeof(repl) - 1);
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, repl);
SStream_replc_str(&OS, '\0', repl);
CHECK_OS_EQUAL_RET_FALSE(OS, repl);
CHECK_INT_EQUAL_RET_FALSE(OS.index, 511);
/// Last char is replaced.
memset(repl, 'A', sizeof(repl) - 1);
repl[sizeof(repl) - 2] = 'X';
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, repl);
SStream_replc_str(&OS, 'X', "Y");
repl[sizeof(repl) - 2] = 'Y';
CHECK_OS_EQUAL_RET_FALSE(OS, repl);
CHECK_INT_EQUAL_RET_FALSE(OS.index, 511);
// Possible overflow
char too_long[SSTREAM_BUF_LEN + 10] = { 0 };
memset(too_long, 'A', sizeof(too_long) - 1);
SStream_Flush(&OS, NULL);
SStream_concat0(&OS, "\tA--");
SStream_replc_str(&OS, 'A', too_long);
CHECK_OS_EQUAL_RET_FALSE(OS, "\tA--");
CHECK_INT_EQUAL_RET_FALSE(OS.index, 4);
return true;
}
int main()
{
bool result = true;
result &= test_markup_os();
result &= test_overflow_check();
result &= test_printint8();
result &= test_printint16();
result &= test_printint32();
result &= test_printint64();
result &= test_printint32_bang();
result &= test_printint64_bang();
result &= test_printuint32_bang();
result &= test_printuint64_bang();
result &= test_replc();
result &= test_replc_str();
result &= test_copy_mnem_opstr();
result &= test_trimls();
if (result) {
printf("All tests passed.\n");
} else {
printf("Some tests failed.\n");
}
return result ? 0 : -1;
}

76
external/capstone/tests/unit/utils.c vendored Normal file
View File

@@ -0,0 +1,76 @@
// Copyright © 2024 Rot127 <unisono@quyllur.org>
// SPDX-License-Identifier: BSD-3
#include "unit_test.h"
#include "../utils.h"
#include <stdio.h>
#include <string.h>
static bool test_str_append_no_realloc()
{
printf("Test test_str_append_no_realloc\n");
char str_a[] = "AAAA\0\0\0\0\0";
char str_b[] = "BBBB";
char str_c[] = "\0\0\0\0\0";
CHECK_NULL_RET_FALSE(str_append(NULL, NULL));
CHECK_NULL_RET_FALSE(str_append(str_a, NULL));
CHECK_NULL_RET_FALSE(str_append(NULL, str_b));
str_append_no_realloc(str_a, sizeof(str_a), str_c);
CHECK_STR_EQUAL_RET_FALSE(str_a, "AAAA");
str_append_no_realloc(str_a, sizeof(str_a), str_b);
CHECK_STR_EQUAL_RET_FALSE(str_a, "AAAABBBB");
str_append_no_realloc(str_c, sizeof(str_c), str_b);
CHECK_STR_EQUAL_RET_FALSE(str_c, "BBBB");
str_append_no_realloc(str_b, sizeof(str_b), str_c);
CHECK_STR_EQUAL_RET_FALSE(str_b, "BBBB");
return true;
}
static bool test_str_append()
{
printf("Test test_str_append\n");
char *str_a = NULL;
char *str_b = NULL;
CHECK_NULL_RET_FALSE(str_append(str_a, str_b));
str_a = calloc(5, sizeof(char));
memcpy(str_a, "AAAA", 5);
CHECK_NULL_RET_FALSE(str_append(str_a, str_b));
str_b = calloc(5, sizeof(char));
str_a = str_append(str_a, str_b);
CHECK_STR_EQUAL_RET_FALSE(str_a, "AAAA");
memcpy(str_b, "BBBB", 5);
str_a = str_append(str_a, str_b);
CHECK_STR_EQUAL_RET_FALSE(str_a, "AAAABBBB");
memset(str_a, 0, strlen(str_a) + 1);
str_a = str_append(str_a, str_b);
CHECK_STR_EQUAL_RET_FALSE(str_a, "BBBB");
free(str_a);
free(str_b);
return true;
}
int main()
{
bool result = true;
result &= test_str_append();
result &= test_str_append_no_realloc();
if (result) {
printf("All tests passed.\n");
} else {
printf("Some tests failed.\n");
}
return result ? 0 : -1;
}