From fbc7300d069f433af68e89a69ddce842cfd1550f Mon Sep 17 00:00:00 2001 From: xwx1135370 Date: Mon, 1 Sep 2025 09:07:39 +0800 Subject: [PATCH] Add string test issue:https://gitee.com/openharmony/third_party_musl/issues/ICQUZ1?from=project-issue Signed-off-by: xwx1135370 --- .../functionalext/supplement/string/bzero.c | 34 ++++++ .../functionalext/supplement/string/index.c | 75 ++++++++++++ .../functionalext/supplement/string/memccpy.c | 107 ++++++++++++++++++ .../functionalext/supplement/string/memmem.c | 84 ++++++++++++++ .../functionalext/supplement/string/strcat.c | 95 ++++++++++++++++ .../string/string_gtest/string_bcmp_test.cpp | 49 ++++++++ 6 files changed, 444 insertions(+) diff --git a/libc-test/src/functionalext/supplement/string/bzero.c b/libc-test/src/functionalext/supplement/string/bzero.c index 9d299342a..44e1419ed 100644 --- a/libc-test/src/functionalext/supplement/string/bzero.c +++ b/libc-test/src/functionalext/supplement/string/bzero.c @@ -46,9 +46,43 @@ void bzero_0200(void) } } +/** + * @tc.name : bzero_0300 + * @tc.desc : Verify that bzero clears partial content of a string + * @tc.level : Level 1 + */ +void bzero_0300(void) +{ + char str[20] = "hello world"; + bzero(str + 6, 5); // Clear "world" + if (str[0] != 'h' || str[6] != 0) { + t_error("%s bzero failed", __func__); + } +} + +/** + * @tc.name : bzero_0600 + * @tc.desc : Verify that bzero works correctly on the maximum buffer size + * @tc.level : Level 2 + */ +void bzero_0400(void) +{ + #define MAX_SIZE 1024 + char buffer[MAX_SIZE]; + memset(buffer, 0xFF, MAX_SIZE); + bzero(buffer, MAX_SIZE); + for (int i = 0; i < MAX_SIZE; i++) { + if (buffer[i] != 0) { + t_error("%s bzero failed at position %d", __func__, i); + } + } +} + int main(int argc, char *argv[]) { bzero_0100(); bzero_0200(); + bzero_0300(); + bzero_0400(); return t_status; } \ No newline at end of file diff --git a/libc-test/src/functionalext/supplement/string/index.c b/libc-test/src/functionalext/supplement/string/index.c index 0cb47d611..4a57e4b84 100644 --- a/libc-test/src/functionalext/supplement/string/index.c +++ b/libc-test/src/functionalext/supplement/string/index.c @@ -62,10 +62,85 @@ void index_0300(void) } } +/** + * @tc.name : index_0400 + * @tc.desc : Verify index finds null terminator character + * @tc.level : Level 1 + */ +void index_0400(void) +{ + char *str = "hello"; + char *result = index(str, '\0'); + if (result != str + 5) { + t_error("%s index get result is %s are not want %s\n", __func__, result, str + 5); + } +} + +/** + * @tc.name : index_0500 + * @tc.desc : Verify index works with empty string + * @tc.level : Level 2 + */ +void index_0500(void) +{ + char *str = ""; + char *result = index(str, 'h'); + if (result != NULL) { + t_error("%s index get result is %s are not want NULL\n", __func__, result); + } +} + +/** + * @tc.name : index_0600 + * @tc.desc : Verify index finds first character in string + * @tc.level : Level 1 + */ +void index_0600(void) +{ + char *str = "hello world"; + char *result = index(str, 'h'); + if (result != str) { + t_error("%s index get result is %s are not want %s\n", __func__, result, str); + } +} + +/** + * @tc.name : index_0700 + * @tc.desc : Verify index finds last character in string + * @tc.level : Level 1 + */ +void index_0700(void) +{ + char *str = "hello world"; + char *result = index(str, 'd'); + if (result != str + 10) { + t_error("%s index get result is %s are not want %s\n", __func__, result, str + 10); + } +} + +/** + * @tc.name : index_0800 + * @tc.desc : Verify index works with binary data containing null bytes + * @tc.level : Level 2 + */ +void index_0800(void) +{ + char data[] = {'a', 'b', '\0', 'c', 'd'}; + char *result = index(data, 'c'); + if (result != NULL) { // Expected to return NULL + t_error("%s index should stop at '\\0', but got %p\n", __func__, result); + } +} + int main(int argc, char *argv[]) { index_0100(); index_0200(); index_0300(); + index_0400(); + index_0500(); + index_0600(); + index_0700(); + index_0800(); return t_status; } \ No newline at end of file diff --git a/libc-test/src/functionalext/supplement/string/memccpy.c b/libc-test/src/functionalext/supplement/string/memccpy.c index 255e7c3f3..58530a399 100644 --- a/libc-test/src/functionalext/supplement/string/memccpy.c +++ b/libc-test/src/functionalext/supplement/string/memccpy.c @@ -76,10 +76,117 @@ void memccpy_0300(void) EXPECT_EQ("memccpy_0300", strlen(dest), 0); } +/** + * @tc.name : memccpy_0400 + * @tc.desc : Verify memccpy stops at first occurrence of specified character + * @tc.level : Level 1 + */ +void memccpy_0400(void) +{ + const char src[] = "multiple|delimited|values"; + char dest[32] = {0}; + void *result = memccpy(dest, src, '|', sizeof(src)); + + EXPECT_PTRNE("memccpy_0400", result, NULL); + if (result != NULL) { + EXPECT_STREQ("memccpy_0400", dest, "multiple|"); + EXPECT_EQ("memccpy_0400", (char *)result - dest, strlen("multiple") + 1); + } +} + +/** + * @tc.name : memccpy_0500 + * @tc.desc : Verify memccpy handles binary data with null bytes + * @tc.level : Level 2 + */ +void memccpy_0500(void) +{ + const char src[] = {'a', 'b', '\0', 'c', 'd'}; + char dest[5] = {0}; + void *result = memccpy(dest, src, 'd', sizeof(src)); + + EXPECT_PTRNE("memccpy_0500", result, NULL); + if (result != NULL) { + EXPECT_EQ("memccpy_0500", memcmp(dest, src, 5), 0); + EXPECT_EQ("memccpy_0500", (char *)result - dest, 5); + } +} + +/** + * @tc.name : memccpy_0600 + * @tc.desc : Verify memccpy copies full length when stop char not found + * @tc.level : Level 1 + */ +void memccpy_0600(void) +{ + const char src[] = "no_stop_char_here"; + char dest[32] = {0}; + void *result = memccpy(dest, src, 'X', strlen(src)); + + EXPECT_PTREQ("memccpy_0600", result, NULL); + EXPECT_STREQ("memccpy_0600", dest, src); +} + +/** + * @tc.name : memccpy_0700 + * @tc.desc : Verify memccpy with stop character at last position + * @tc.level : Level 1 + */ +void memccpy_0700(void) +{ + const char src[] = "stop_at_end$"; + char dest[32] = {0}; + void *result = memccpy(dest, src, '$', strlen(src)); + + EXPECT_PTRNE("memccpy_0700", result, NULL); + if (result != NULL) { + EXPECT_STREQ("memccpy_0700", dest, src); + EXPECT_EQ("memccpy_0700", (char *)result - dest, strlen(src)); + } +} + +/** + * @tc.name : memccpy_0900 + * @tc.desc : Verify memccpy with maximum copy length before stop char + * @tc.level : Level 2 + */ +void memccpy_0800(void) +{ + const char src[] = "copy|this"; + char dest[32] = {0}; + void *result = memccpy(dest, src, '|', 4); // Should stop at length before seeing '|' + + EXPECT_PTREQ("memccpy_0800", result, NULL); + EXPECT_EQ("memccpy_0800", memcmp(dest, "copy", 4), 0); +} + +/** + * @tc.name : memccpy_0900 + * @tc.desc : Verify memccpy with stop character being the first byte + * @tc.level : Level 1 + */ +void memccpy_0900(void) +{ + const char src[] = "*start*with*star"; + char dest[32] = {0}; + void *result = memccpy(dest, src, '*', strlen(src)); + + if (result != NULL) { + EXPECT_PTREQ("memccpy_0900", result, dest + 1); + EXPECT_EQ("memccpy_0900", dest[0], '*'); + } +} + int main(void) { memccpy_0100(); memccpy_0200(); memccpy_0300(); + memccpy_0400(); + memccpy_0500(); + memccpy_0600(); + memccpy_0700(); + memccpy_0800(); + memccpy_0900(); return t_status; } \ No newline at end of file diff --git a/libc-test/src/functionalext/supplement/string/memmem.c b/libc-test/src/functionalext/supplement/string/memmem.c index 18a188dc6..d05ac27f6 100644 --- a/libc-test/src/functionalext/supplement/string/memmem.c +++ b/libc-test/src/functionalext/supplement/string/memmem.c @@ -57,10 +57,94 @@ void memmem_0200(void) EXPECT_PTREQ("memmem_0200", ptr, NULL); } +/** + * @tc.name : memmem_0300 + * @tc.desc : Verify memmem returns NULL when substring not found + * @tc.level : Level 1 + */ +void memmem_0300(void) +{ + const char buffer[] = "test musl"; + const char needle[] = "notfound"; + char *ptr = memmem(buffer, sizeof(buffer), needle, sizeof(needle)-1); + EXPECT_PTREQ("memmem_0300", ptr, NULL); +} + +/** + * @tc.name : memmem_0400 + * @tc.desc : Verify memmem handles empty needle correctly + * @tc.level : Level 1 + */ +void memmem_0400(void) +{ + const char buffer[] = "test musl"; + const char needle[] = ""; + char *ptr = memmem(buffer, sizeof(buffer), needle, 0); + EXPECT_PTREQ("memmem_0400", ptr, buffer); +} + +/** + * @tc.name : memmem_0500 + * @tc.desc : Verify memmem handles binary data correctly + * @tc.level : Level 2 + */ +void memmem_0500(void) +{ + const unsigned char buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05}; + const unsigned char needle[] = {0x03, 0x04}; + char *ptr = memmem(buffer, sizeof(buffer), needle, sizeof(needle)); + EXPECT_PTREQ("memmem_0500", ptr, (char *)buffer + 2); +} + +/** + * @tc.name : memmem_0600 + * @tc.desc : Verify memmem returns NULL when needle larger than haystack + * @tc.level : Level 2 + */ +void memmem_0600(void) +{ + const char buffer[] = "test"; + const char needle[] = "test string"; + char *ptr = memmem(buffer, sizeof(buffer)-1, needle, sizeof(needle)-1); + EXPECT_PTREQ("memmem_0600", ptr, NULL); +} + +/** + * @tc.name : memmem_0700 + * @tc.desc : Verify memmem finds partial matches correctly + * @tc.level : Level 2 + */ +void memmem_0700(void) +{ + const char buffer[] = "test musl"; + const char needle[] = "musx"; + char *ptr = memmem(buffer, sizeof(buffer), needle, 3); // Only compare first 3 chars + EXPECT_PTREQ("memmem_0700", ptr, buffer + 5); +} + +/** + * @tc.name : memmem_0800 + * @tc.desc : Verify memmem handles zero-length haystack correctly + * @tc.level : Level 2 + */ +void memmem_0800(void) +{ + const char buffer[] = ""; + const char needle[] = "test"; + char *ptr = memmem(buffer, 0, needle, sizeof(needle)-1); + EXPECT_PTREQ("memmem_0800", ptr, NULL); +} + int main(void) { memmem_0100(); memmem_0200(); + memmem_0300(); + memmem_0400(); + memmem_0500(); + memmem_0600(); + memmem_0700(); + memmem_0800(); return t_status; } \ No newline at end of file diff --git a/libc-test/src/functionalext/supplement/string/strcat.c b/libc-test/src/functionalext/supplement/string/strcat.c index cecbdd1b5..62e9b2520 100644 --- a/libc-test/src/functionalext/supplement/string/strcat.c +++ b/libc-test/src/functionalext/supplement/string/strcat.c @@ -32,8 +32,103 @@ void strcat_0100(void) EXPECT_STREQ("strcat_0100", ret, "SourceDestination"); } +/** + * @tc.name : strcat_0200 + * @tc.desc : Verify concatenating empty string + * @tc.level : Level 1 + */ +void strcat_0200(void) +{ + char src[LENGTH] = "Hello"; + char *ret = strcat(src, ""); + if (ret != NULL) { + EXPECT_STREQ("strcat_0200", ret, "Hello"); + EXPECT_STREQ("strcat_0200", src, "Hello"); + } +} + +/** + * @tc.name : strcat_0300 + * @tc.desc : Verify concatenating to empty string + * @tc.level : Level 1 + */ +void strcat_0300(void) +{ + char src[LENGTH] = ""; + char *ret = strcat(src, "World"); + if (ret != NULL) { + EXPECT_STREQ("strcat_0300", ret, "World"); + EXPECT_STREQ("strcat_0300", src, "World"); + } +} + +/** + * @tc.name : strcat_0400 + * @tc.desc : Verify concatenation with exact buffer size + * @tc.level : Level 2 + */ +void strcat_0400(void) +{ + char src[12] = "Hello"; + char *ret = strcat(src, "World"); + if (ret != NULL) { + EXPECT_STREQ("strcat_0400", ret, "HelloWorld"); + } +} + +/** + * @tc.name : strcat_0500 + * @tc.desc : Verify multiple concatenations + * @tc.level : Level 1 + */ +void strcat_0500(void) +{ + char src[LENGTH] = "Start"; + strcat(src, "-"); + strcat(src, "Middle"); + char *ret = strcat(src, "-End"); + if (ret != NULL) { + EXPECT_STREQ("strcat_0500", ret, "Start-Middle-End"); + } +} + +/** + * @tc.name : strcat_0600 + * @tc.desc : Verify concatenation with special characters + * @tc.level : Level 1 + */ +void strcat_0600(void) +{ + char src[LENGTH] = "Text"; + char *ret = strcat(src, "\t\n\r\0Special"); + if (ret != NULL) { + // Note: Strcmp will stop at \0, so only the content before \0 will be compared + EXPECT_EQ("strcat_0600", memcmp(ret, "Text\t\n\r", 7), 0); + } +} + +/** + * @tc.name : strcat_0700 + * @tc.desc : Verify return pointer points to dest + * @tc.level : Level 1 + */ +void strcat_0700(void) +{ + char src[LENGTH] = "Base"; + char *ret = strcat(src, "String"); + if (ret != NULL) { + EXPECT_PTREQ("strcat_0700", ret, src); + } +} + int main(void) { strcat_0100(); + strcat_0200(); + strcat_0300(); + strcat_0400(); + strcat_0500(); + strcat_0600(); + strcat_0700(); return t_status; } diff --git a/libc-test/src/functionalext/supplement/string/string_gtest/string_bcmp_test.cpp b/libc-test/src/functionalext/supplement/string/string_gtest/string_bcmp_test.cpp index 1df29ebd8..800b1b134 100644 --- a/libc-test/src/functionalext/supplement/string/string_gtest/string_bcmp_test.cpp +++ b/libc-test/src/functionalext/supplement/string/string_gtest/string_bcmp_test.cpp @@ -32,4 +32,53 @@ HWTEST_F(StringBcmpTest, bcmp_002, TestSize.Level1) const char* str1 = "hello"; const char* str2 = "world"; EXPECT_NE(bcmp(str1, str2, strlen(str1)), strlen(str1)); +} + +/** + * @tc.name: bcmp_003 + * @tc.desc: Verify that if two strings are equal in the first n bytes, the return value of bcmp function is 0. + * @tc.type: FUNC + */ +HWTEST_F(StringBcmpTest, bcmp_003, TestSize.Level1) +{ + const char* str1 = "hello world"; + const char* str2 = "hello there"; + EXPECT_EQ(bcmp(str1, str2, 5), 0); +} + +/** + * @tc.name: bcmp_004 + * @tc.desc: Verify that if compare length is 0, the return value of bcmp function is 0. + * @tc.type: FUNC + */ +HWTEST_F(StringBcmpTest, bcmp_004, TestSize.Level1) +{ + const char* str1 = "hello"; + const char* str2 = "world"; + EXPECT_EQ(bcmp(str1, str2, 0), 0); +} + +/** + * @tc.name: bcmp_005 + * @tc.desc: Verify that bcmp function can correctly compare binary data. + * @tc.type: FUNC + */ +HWTEST_F(StringBcmpTest, bcmp_005, TestSize.Level1) +{ + unsigned char data1[] = {0x01, 0x02, 0x03, 0x04}; + unsigned char data2[] = {0x01, 0x02, 0x03, 0x05}; + EXPECT_NE(bcmp(data1, data2, sizeof(data1)), 0); +} + +/** + * @tc.name: bcmp_006 + * @tc.desc: Verify that bcmp function can correctly handle single character comparison. + * @tc.type: FUNC + */ +HWTEST_F(StringBcmpTest, bcmp_006, TestSize.Level1) +{ + const char* str1 = "A"; + const char* str2 = "B"; + EXPECT_NE(bcmp(str1, str2, 1), 0); + EXPECT_EQ(bcmp(str1, str1, 1), 0); } \ No newline at end of file -- Gitee