sk_string_test.cpp File Reference

#include <gtest/gtest.h>
#include "../../src/libc/sk_string.c"

Include dependency graph for sk_string_test.cpp:

Go to the source code of this file.

Macros
#define	memcpy   sk_memcpy
#define	memmove   sk_memmove
#define	memset   sk_memset
#define	memcmp   sk_memcmp
#define	memchr   sk_memchr
#define	strcpy   strcpy
#define	strncpy   sk_strncpy
#define	strcat   sk_strcat
#define	strcmp   sk_strcmp
#define	strncmp   sk_strncmp
#define	strlen   sk_strlen
#define	strnlen   sk_strnlen
#define	strchr   sk_strchr
#define	strrchr   sk_strrchr

Functions
	TEST (SkStringTest, Memcpy)
	TEST (SkStringTest, Memmove)
	TEST (SkStringTest, Memset)
	TEST (SkStringTest, Memcmp)
	TEST (SkStringTest, Memchr)
	TEST (SkStringTest, Strcpy)
	TEST (SkStringTest, Strncpy)
	TEST (SkStringTest, Strcat)
	TEST (SkStringTest, Strcmp)
	TEST (SkStringTest, Strncmp)
	TEST (SkStringTest, Strlen)
	TEST (SkStringTest, Strnlen)
	TEST (SkStringTest, Strchr)
	TEST (SkStringTest, Strrchr)
	TEST (SkStringTest, MemcpyEdgeCases)
	TEST (SkStringTest, MemsetEdgeCases)
	TEST (SkStringTest, StrcmpEdgeCases)
	TEST (SkStringTest, StrlenEdgeCases)
	TEST (SkStringTest, StrnlenEdgeCases)
	TEST (SkStringTest, StrchrEdgeCases)
	TEST (SkStringTest, StrrchrEdgeCases)
	TEST (SkStringTest, MemmoveOverlapForward)
	TEST (SkStringTest, MemmoveOverlapBackward)
	TEST (SkStringTest, MemmoveNoOverlap)
	TEST (SkStringTest, MemchrNotFound)
	TEST (SkStringTest, MemcmpEqual)
	TEST (SkStringTest, MemcmpDifferentLengths)
	TEST (SkStringTest, StrcatMultiple)
	TEST (SkStringTest, StrncpyPadding)

Macro Definition Documentation

memchr

#define memchr   sk_memchr

Definition at line 12 of file sk_string_test.cpp.

memcmp

#define memcmp   sk_memcmp

Definition at line 11 of file sk_string_test.cpp.

memcpy

#define memcpy   sk_memcpy

Copyright

Copyright The SimpleKernel Contributors

Definition at line 8 of file sk_string_test.cpp.

memmove

#define memmove   sk_memmove

Definition at line 9 of file sk_string_test.cpp.

memset

#define memset   sk_memset

Definition at line 10 of file sk_string_test.cpp.

strcat

#define strcat   sk_strcat

Definition at line 15 of file sk_string_test.cpp.

strchr

#define strchr   sk_strchr

Definition at line 20 of file sk_string_test.cpp.

strcmp

#define strcmp   sk_strcmp

Definition at line 16 of file sk_string_test.cpp.

strcpy

#define strcpy   strcpy

Definition at line 13 of file sk_string_test.cpp.

strlen

#define strlen   sk_strlen

Definition at line 18 of file sk_string_test.cpp.

strncmp

#define strncmp   sk_strncmp

Definition at line 17 of file sk_string_test.cpp.

strncpy

#define strncpy   sk_strncpy

Definition at line 14 of file sk_string_test.cpp.

strnlen

#define strnlen   sk_strnlen

Definition at line 19 of file sk_string_test.cpp.

strrchr

#define strrchr   sk_strrchr

Definition at line 21 of file sk_string_test.cpp.

Function Documentation

TEST() [1/29]

TEST	(	SkStringTest	,
		Memchr
	)

Definition at line 77 of file sk_string_test.cpp.

                           {
  char s[] = "hello world";
  const void* res = memchr(s, 'w', 11);
  EXPECT_EQ(static_cast<const char*>(res), &s[6]);
 
  res = memchr(s, 'z', 11);
  EXPECT_EQ(res, nullptr);
}

TEST() [2/29]

TEST	(	SkStringTest	,
		MemchrNotFound
	)

Definition at line 272 of file sk_string_test.cpp.

                                   {
  char s[] = "hello world";
  EXPECT_EQ(memchr(s, 'x', 11), nullptr);
  EXPECT_EQ(memchr(s, 'z', 11), nullptr);
}

TEST() [3/29]

TEST	(	SkStringTest	,
		Memcmp
	)

Definition at line 66 of file sk_string_test.cpp.

                           {
  char s1[] = "abc";
  char s2[] = "abc";
  char s3[] = "abd";
  char s4[] = "aba";
 
  EXPECT_EQ(memcmp(s1, s2, 3), 0);
  EXPECT_LT(memcmp(s1, s3, 3), 0);  // 'c' < 'd' -> 99 - 100 < 0
  EXPECT_GT(memcmp(s1, s4, 3), 0);  // 'c' > 'a'
}

TEST() [4/29]

TEST	(	SkStringTest	,
		MemcmpDifferentLengths
	)

Definition at line 284 of file sk_string_test.cpp.

                                           {
  char s1[] = "abc";
  char s2[] = "abcd";
  // 只比较前3个字节
  EXPECT_EQ(memcmp(s1, s2, 3), 0);
}

TEST() [5/29]

TEST	(	SkStringTest	,
		MemcmpEqual
	)

Definition at line 278 of file sk_string_test.cpp.

                                {
  char s1[] = "test";
  char s2[] = "test";
  EXPECT_EQ(memcmp(s1, s2, 4), 0);
}

TEST() [6/29]

TEST	(	SkStringTest	,
		Memcpy
	)

Definition at line 34 of file sk_string_test.cpp.

                           {
  char src[] = "hello";
  char dest[10];
  memcpy(dest, src, 6);
  EXPECT_STREQ(dest, "hello");
}

TEST() [7/29]

TEST	(	SkStringTest	,
		MemcpyEdgeCases
	)

Definition at line 160 of file sk_string_test.cpp.

                                    {
  char src[] = "test";
  char dest[10];
 
  // 零长度复制
  memcpy(dest, src, 0);
 
  // 单字节复制
  memcpy(dest, src, 1);
  EXPECT_EQ(dest[0], 't');
}

TEST() [8/29]

TEST	(	SkStringTest	,
		Memmove
	)

Definition at line 41 of file sk_string_test.cpp.

                            {
  char str[] = "memory move test";
  // Overlap: dest > src
  memmove(str + 7, str, 6);  // "memory " -> "memory " at pos 7
  // "memory memoryest"
  EXPECT_STREQ(str, "memory memoryest");
 
  char str2[] = "memory move test";
  // Overlap: dest < src
  memmove(str2, str2 + 7, 4);  // "move" -> starts at 0
  // "move ry move test"
  EXPECT_EQ(str2[0], 'm');
  EXPECT_EQ(str2[1], 'o');
  EXPECT_EQ(str2[2], 'v');
  EXPECT_EQ(str2[3], 'e');
}

TEST() [9/29]

TEST	(	SkStringTest	,
		MemmoveNoOverlap
	)

Definition at line 264 of file sk_string_test.cpp.

                                     {
  // 无重叠
  char src[] = "source";
  char dest[10];
  memmove(dest, src, 7);
  EXPECT_STREQ(dest, "source");
}

TEST() [10/29]

TEST	(	SkStringTest	,
		MemmoveOverlapBackward
	)

Definition at line 253 of file sk_string_test.cpp.

                                           {
  // 测试后向重叠: dest < src
  char str[] = "1234567890";
  memmove(str, str + 3, 5);  // "4567567890"
  EXPECT_EQ(str[0], '4');
  EXPECT_EQ(str[1], '5');
  EXPECT_EQ(str[2], '6');
  EXPECT_EQ(str[3], '7');
  EXPECT_EQ(str[4], '8');
}

TEST() [11/29]

TEST	(	SkStringTest	,
		MemmoveOverlapForward
	)

Definition at line 242 of file sk_string_test.cpp.

                                          {
  // 测试前向重叠: dest > src
  char str[] = "1234567890";
  memmove(str + 3, str, 5);  // "12312345890"
  EXPECT_EQ(str[3], '1');
  EXPECT_EQ(str[4], '2');
  EXPECT_EQ(str[5], '3');
  EXPECT_EQ(str[6], '4');
  EXPECT_EQ(str[7], '5');
}

TEST() [12/29]

TEST	(	SkStringTest	,
		Memset
	)

Definition at line 58 of file sk_string_test.cpp.

                           {
  char buffer[10];
  memset(buffer, 'A', 5);
  for (int i = 0; i < 5; ++i) {
    EXPECT_EQ(buffer[i], 'A');
  }
}

TEST() [13/29]

TEST	(	SkStringTest	,
		MemsetEdgeCases
	)

Definition at line 172 of file sk_string_test.cpp.

                                    {
  char buffer[10];
 
  // 零长度设置
  memset(buffer, 'A', 0);
 
  // 使用 0 填充
  memset(buffer, 0, 5);
  for (int i = 0; i < 5; ++i) {
    EXPECT_EQ(buffer[i], 0);
  }
 
  // 使用负值填充 (转换为 unsigned char)
  memset(buffer, -1, 3);
  for (int i = 0; i < 3; ++i) {
    EXPECT_EQ(static_cast<unsigned char>(buffer[i]), 255);
  }
}

TEST() [14/29]

TEST	(	SkStringTest	,
		Strcat
	)

Definition at line 118 of file sk_string_test.cpp.

                           {
  char dest[20] = "hello";
  sk_strcat(dest, " world");
  EXPECT_STREQ(dest, "hello world");
}

TEST() [15/29]

TEST	(	SkStringTest	,
		StrcatMultiple
	)

Definition at line 291 of file sk_string_test.cpp.

                                   {
  char dest[30] = "hello";
  sk_strcat(dest, " ");
  sk_strcat(dest, "world");
  sk_strcat(dest, "!");
  EXPECT_STREQ(dest, "hello world!");
}

TEST() [16/29]

TEST	(	SkStringTest	,
		Strchr
	)

Definition at line 146 of file sk_string_test.cpp.

                           {
  char s[] = "hello";
  EXPECT_STREQ(strchr(s, 'e'), "ello");
  EXPECT_EQ(strchr(s, 'z'), nullptr);
  EXPECT_STREQ(strchr(s, 'l'), "llo");  // first 'l'
}

TEST() [17/29]

TEST	(	SkStringTest	,
		StrchrEdgeCases
	)

Definition at line 222 of file sk_string_test.cpp.

                                    {
  char s[] = "hello";
 
  // 查找空字符
  EXPECT_EQ(strchr(s, '\0'), &s[5]);
 
  // 第一个字符
  EXPECT_EQ(strchr(s, 'h'), s);
}

TEST() [18/29]

TEST	(	SkStringTest	,
		Strcmp
	)

Definition at line 124 of file sk_string_test.cpp.

                           {
  EXPECT_EQ(strcmp("abc", "abc"), 0);
  EXPECT_LT(strcmp("abc", "abd"), 0);
  EXPECT_GT(strcmp("abc", "aba"), 0);
  EXPECT_LT(strcmp("abc", "abcd"), 0);
}

TEST() [19/29]

TEST	(	SkStringTest	,
		StrcmpEdgeCases
	)

Definition at line 191 of file sk_string_test.cpp.

                                    {
  // 空字符串比较
  EXPECT_EQ(strcmp("", ""), 0);
  EXPECT_LT(strcmp("", "a"), 0);
  EXPECT_GT(strcmp("a", ""), 0);
 
  // 一个字符串是另一个的前缀
  EXPECT_LT(strcmp("abc", "abcd"), 0);
  EXPECT_GT(strcmp("abcd", "abc"), 0);
}

TEST() [20/29]

TEST	(	SkStringTest	,
		Strcpy
	)

Definition at line 86 of file sk_string_test.cpp.

                           {
  char src[] = "test";
  char dest[10];
  strcpy(dest, src);
  EXPECT_STREQ(dest, "test");
}

TEST() [21/29]

TEST	(	SkStringTest	,
		Strlen
	)

Definition at line 136 of file sk_string_test.cpp.

                           {
  EXPECT_EQ(strlen("hello"), 5);
  EXPECT_EQ(strlen(""), 0);
}

TEST() [22/29]

TEST	(	SkStringTest	,
		StrlenEdgeCases
	)

Definition at line 202 of file sk_string_test.cpp.

                                    {
  // 空字符串
  EXPECT_EQ(strlen(""), 0);
 
  // 只有空字符
  const char null_str[] = {'\0', 'a', 'b', '\0'};
  EXPECT_EQ(strlen(null_str), 0);
}

TEST() [23/29]

TEST	(	SkStringTest	,
		Strncmp
	)

Definition at line 131 of file sk_string_test.cpp.

                            {
  EXPECT_EQ(sk_strncmp("abc", "abd", 2), 0);  // "ab" vs "ab"
  EXPECT_LT(sk_strncmp("abc", "abd", 3), 0);
}

TEST() [24/29]

TEST	(	SkStringTest	,
		Strncpy
	)

Definition at line 93 of file sk_string_test.cpp.

                            {
  char src[] = "test string";
  char dest[20];
 
  // Normal case
  sk_strncpy(dest, src, 4);
  // manual null termination check if expected,
  // but standard strncpy does NOT null terminate if limit reached?
  // sk_string.c implementation should be checked.
  // Usually strncpy pads with nulls if n > src_len, and does NOT null terminate
  // if n <= src_len
 
  // Let's verify behavior with simpler test first
  memset(dest, 0, 20);
  sk_strncpy(dest, "abc", 5);
  EXPECT_STREQ(dest, "abc");
 
  sk_strncpy(dest, "abcdef", 3);
  EXPECT_EQ(dest[0], 'a');
  EXPECT_EQ(dest[1], 'b');
  EXPECT_EQ(dest[2], 'c');
  // dest[3] should remain 0 from memset
  EXPECT_EQ(dest[3], '\0');
}

TEST() [25/29]

TEST	(	SkStringTest	,
		StrncpyPadding
	)

Definition at line 299 of file sk_string_test.cpp.

                                   {
  char dest[10];
  memset(dest, 'X', 10);  // 用 'X' 填充
 
  // 复制短字符串，应该填充空字符
  sk_strncpy(dest, "ab", 5);
  EXPECT_EQ(dest[0], 'a');
  EXPECT_EQ(dest[1], 'b');
  EXPECT_EQ(dest[2], '\0');
  EXPECT_EQ(dest[3], '\0');
  EXPECT_EQ(dest[4], '\0');
}

TEST() [26/29]

TEST	(	SkStringTest	,
		Strnlen
	)

Definition at line 141 of file sk_string_test.cpp.

                            {
  EXPECT_EQ(strnlen("hello", 10), 5);
  EXPECT_EQ(strnlen("hello", 3), 3);
}

TEST() [27/29]

TEST	(	SkStringTest	,
		StrnlenEdgeCases
	)

Definition at line 211 of file sk_string_test.cpp.

                                     {
  // n 为 0
  EXPECT_EQ(strnlen("hello", 0), 0);
 
  // n 大于字符串长度
  EXPECT_EQ(strnlen("hi", 100), 2);
 
  // n 等于字符串长度
  EXPECT_EQ(strnlen("hello", 5), 5);
}

TEST() [28/29]

TEST	(	SkStringTest	,
		Strrchr
	)

Definition at line 153 of file sk_string_test.cpp.

                            {
  char s[] = "hello";
  EXPECT_STREQ(strrchr(s, 'l'), "lo");  // last 'l'
  EXPECT_EQ(strrchr(s, 'z'), nullptr);
}

TEST() [29/29]

TEST	(	SkStringTest	,
		StrrchrEdgeCases
	)

Definition at line 232 of file sk_string_test.cpp.

                                     {
  char s[] = "hello";
 
  // 查找空字符
  EXPECT_EQ(strrchr(s, '\0'), &s[5]);
 
  // 第一个也是最后一个
  EXPECT_EQ(strrchr(s, 'h'), s);
}