Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit 6426fc9

Browse filesBrowse files
mysterywolfmysterywolf
committed
[core][utest] add WCharacter test cases
1 parent 785bb4c commit 6426fc9
Copy full SHA for 6426fc9

File tree

Expand file treeCollapse file tree

2 files changed

+337
-0
lines changed
Filter options
Expand file treeCollapse file tree

2 files changed

+337
-0
lines changed

‎core/utest/SConscript

Copy file name to clipboard
+10Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
from building import *
2+
3+
src = []
4+
5+
if GetDepend('RT_USING_CI_ACTION') or GetDepend('RTDUINO_UTEST_CORE'):
6+
src += Glob('TC_*.c')
7+
8+
group = DefineGroup('utestcases', src, depend = [''])
9+
10+
Return('group')

‎core/utest/TC_WCharacter.c

Copy file name to clipboard
+327Lines changed: 327 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,327 @@
1+
/*
2+
* Copyright (c) 2021-2025, RTduino Development Team
3+
*
4+
* SPDX-License-Identifier: Apache-2.0
5+
*
6+
* https://github.com/RTduino/RTduino
7+
* https://gitee.com/rtduino/RTduino
8+
*
9+
* Change Logs:
10+
* Date Author Notes
11+
* 2025-01-04 Meco Man first version
12+
*/
13+
14+
#include <RTduino.h>
15+
#include <WCharacter.h>
16+
#include <utest.h>
17+
18+
/* Test case for isAlphaNumeric */
19+
static void TC_isAlphaNumeric(void)
20+
{
21+
for (int i = 0; i <= 127; i++) {
22+
if (isalnum(i)) {
23+
uassert_true(isAlphaNumeric(i)); /* Alphanumeric characters should return true */
24+
} else {
25+
uassert_false(isAlphaNumeric(i)); /* Non-alphanumeric characters should return false */
26+
}
27+
}
28+
/* Specific tests */
29+
uassert_true(isAlphaNumeric('A'));
30+
uassert_true(isAlphaNumeric('z'));
31+
uassert_true(isAlphaNumeric('0'));
32+
uassert_true(isAlphaNumeric('9'));
33+
uassert_false(isAlphaNumeric(' '));
34+
uassert_false(isAlphaNumeric('@'));
35+
}
36+
37+
/* Test case for isAlpha */
38+
static void TC_isAlpha(void)
39+
{
40+
for (int i = 0; i <= 127; i++) {
41+
if (isalpha(i)) {
42+
uassert_true(isAlpha(i)); /* Alphabetic characters should return true */
43+
} else {
44+
uassert_false(isAlpha(i)); /* Non-alphabetic characters should return false */
45+
}
46+
}
47+
/* Specific tests */
48+
uassert_true(isAlpha('A'));
49+
uassert_true(isAlpha('z'));
50+
uassert_false(isAlpha('0'));
51+
uassert_false(isAlpha(' '));
52+
}
53+
54+
static void TC_isAscii(void)
55+
{
56+
/* Test all possible integer values from -255 to 255, focusing on ASCII boundaries */
57+
for (int i = -255; i <= 255; i++) {
58+
if (i >= 0 && i <= 127) {
59+
uassert_true(isAscii(i)); /* Values from 0 to 127 should return true */
60+
} else {
61+
uassert_false(isAscii(i)); /* Other values should return false */
62+
}
63+
}
64+
65+
/* List some specific values for clarity and readability */
66+
uassert_true(isAscii(0)); /* ASCII value 0 should return true */
67+
uassert_true(isAscii(127)); /* ASCII value 127 should return true */
68+
uassert_false(isAscii(-1)); /* Value -1 is not an ASCII character */
69+
uassert_false(isAscii(128)); /* Value 128 is not an ASCII character */
70+
uassert_false(isAscii(255)); /* Value 255 is not an ASCII character */
71+
}
72+
73+
/* Test case for isWhitespace */
74+
static void TC_isWhitespace(void)
75+
{
76+
for (int i = 0; i <= 127; i++) {
77+
if (isblank(i)) {
78+
uassert_true(isWhitespace(i)); /* Blank characters (space, tab) should return true */
79+
} else {
80+
uassert_false(isWhitespace(i)); /* Non-blank characters should return false */
81+
}
82+
}
83+
/* Specific tests */
84+
uassert_true(isWhitespace(' '));
85+
uassert_true(isWhitespace('\t'));
86+
uassert_false(isWhitespace('A'));
87+
uassert_false(isWhitespace('0'));
88+
}
89+
90+
/* Test case for isControl */
91+
static void TC_isControl(void)
92+
{
93+
for (int i = 0; i <= 127; i++) {
94+
if (iscntrl(i)) {
95+
uassert_true(isControl(i)); /* Control characters should return true */
96+
} else {
97+
uassert_false(isControl(i)); /* Non-control characters should return false */
98+
}
99+
}
100+
/* Specific tests */
101+
uassert_true(isControl(0));
102+
uassert_true(isControl(127));
103+
uassert_false(isControl('A'));
104+
uassert_false(isControl(' '));
105+
}
106+
107+
/* Test case for isDigit */
108+
static void TC_isDigit(void)
109+
{
110+
for (int i = 0; i <= 127; i++) {
111+
if (isdigit(i)) {
112+
uassert_true(isDigit(i)); /* Digit characters (0-9) should return true */
113+
} else {
114+
uassert_false(isDigit(i)); /* Non-digit characters should return false */
115+
}
116+
}
117+
/* Specific tests */
118+
uassert_true(isDigit('0'));
119+
uassert_true(isDigit('9'));
120+
uassert_false(isDigit('A'));
121+
uassert_false(isDigit(' '));
122+
}
123+
124+
/* Test case for isGraph */
125+
static void TC_isGraph(void)
126+
{
127+
for (int i = 0; i <= 127; i++) {
128+
if (isgraph(i)) {
129+
uassert_true(isGraph(i)); /* Printable non-space characters should return true */
130+
} else {
131+
uassert_false(isGraph(i)); /* Non-printable or space characters should return false */
132+
}
133+
}
134+
/* Specific tests */
135+
uassert_true(isGraph('A'));
136+
uassert_false(isGraph(' '));
137+
}
138+
139+
/* Test case for isLowerCase */
140+
static void TC_isLowerCase(void)
141+
{
142+
for (int i = 0; i <= 127; i++) {
143+
if (islower(i)) {
144+
uassert_true(isLowerCase(i)); /* Lowercase letters should return true */
145+
} else {
146+
uassert_false(isLowerCase(i)); /* Non-lowercase letters should return false */
147+
}
148+
}
149+
/* Specific tests */
150+
uassert_true(isLowerCase('a'));
151+
uassert_true(isLowerCase('z'));
152+
uassert_false(isLowerCase('A'));
153+
uassert_false(isLowerCase('0'));
154+
}
155+
156+
/* Test case for isPrintable */
157+
static void TC_isPrintable(void)
158+
{
159+
for (int i = 0; i <= 127; i++) {
160+
if (isprint(i)) {
161+
uassert_true(isPrintable(i)); /* Printable characters should return true */
162+
} else {
163+
uassert_false(isPrintable(i)); /* Non-printable characters should return false */
164+
}
165+
}
166+
/* Specific tests */
167+
uassert_true(isPrintable('A'));
168+
uassert_true(isPrintable(' '));
169+
uassert_false(isPrintable(127)); /* ASCII DEL is not printable */
170+
}
171+
172+
/* Test case for isPunct */
173+
static void TC_isPunct(void)
174+
{
175+
for (int i = 0; i <= 127; i++) {
176+
if (ispunct(i)) {
177+
uassert_true(isPunct(i)); /* Punctuation characters should return true */
178+
} else {
179+
uassert_false(isPunct(i)); /* Non-punctuation characters should return false */
180+
}
181+
}
182+
/* Specific tests */
183+
uassert_true(isPunct('!'));
184+
uassert_true(isPunct('.'));
185+
uassert_false(isPunct('A'));
186+
uassert_false(isPunct(' '));
187+
}
188+
189+
/* Test case for isSpace */
190+
static void TC_isSpace(void)
191+
{
192+
for (int i = 0; i <= 127; i++) {
193+
if (isspace(i)) {
194+
uassert_true(isSpace(i)); /* White-space characters should return true */
195+
} else {
196+
uassert_false(isSpace(i)); /* Non-white-space characters should return false */
197+
}
198+
}
199+
/* Specific tests */
200+
uassert_true(isSpace(' '));
201+
uassert_true(isSpace('\n'));
202+
uassert_false(isSpace('A'));
203+
uassert_false(isSpace('0'));
204+
}
205+
206+
/* Test unit for isUpperCase */
207+
static void TC_isUpperCase(void)
208+
{
209+
for (int i = 0; i < 128; i++) {
210+
char c = (char)i;
211+
if (c >= 'A' && c <= 'Z') {
212+
uassert_true(isUpperCase(c));
213+
} else {
214+
uassert_false(isUpperCase(c));
215+
}
216+
}
217+
218+
uassert_false(isUpperCase('\n'));
219+
uassert_false(isUpperCase('\t'));
220+
uassert_false(isUpperCase('\r'));
221+
uassert_false(isUpperCase('\0'));
222+
}
223+
224+
/* Test unit for isHexadecimalDigit */
225+
static void TC_isHexadecimalDigit(void)
226+
{
227+
/* Hexadecimal digits are 0-9, A-F, and a-f */
228+
for (int i = 0; i <= 127; i++) {
229+
boolean expected = (i >= '0' && i <= '9') ||
230+
(i >= 'A' && i <= 'F') ||
231+
(i >= 'a' && i <= 'f');
232+
if (expected) {
233+
uassert_true(isHexadecimalDigit(i));
234+
} else {
235+
uassert_false(isHexadecimalDigit(i));
236+
}
237+
}
238+
239+
/* Test some specific non-ASCII values */
240+
uassert_false(isHexadecimalDigit(128));
241+
uassert_false(isHexadecimalDigit(-1));
242+
uassert_false(isHexadecimalDigit(255));
243+
}
244+
245+
/* Test unit for toAscii */
246+
static void TC_toAscii(void)
247+
{
248+
/* For ASCII values, toAscii should return the value itself */
249+
for (int i = 0; i <= 127; i++) {
250+
uassert_int_equal(toAscii(i), i);
251+
}
252+
253+
uassert_int_equal(toAscii(0xf7), 0x77);
254+
uassert_int_equal(toAscii((unsigned char)0xf7), 0x77);
255+
uassert_int_equal(toAscii(0x3030), 0x30);
256+
uassert_int_equal(toAscii(' '), ' ');
257+
uassert_int_equal(toAscii('\n'), '\n');
258+
uassert_int_equal(toAscii('\r'), '\r');
259+
uassert_int_equal(toAscii('q'), 'q');
260+
}
261+
262+
/* Test unit for toLowerCase */
263+
static void TC_toLowerCase(void)
264+
{
265+
/* Test all uppercase letters */
266+
for (int i = 'A'; i <= 'Z'; i++) {
267+
uassert_int_equal(toLowerCase(i), i + ('a' - 'A')); /* A-Z should convert to a-z */
268+
}
269+
270+
/* Test lowercase letters and non-alphabetic characters */
271+
for (int i = 0; i <= 127; i++) {
272+
if (i >= 'a' && i <= 'z') {
273+
uassert_int_equal(toLowerCase(i), i); /* a-z should remain unchanged */
274+
}
275+
if (i < 'A' || (i > 'Z' && i < 'a') || i > 'z') {
276+
uassert_int_equal(toLowerCase(i), i); /* Non-alphabetic should remain unchanged */
277+
}
278+
}
279+
280+
/* Test non-ASCII values */
281+
uassert_int_equal(toLowerCase(128), 128); /* Non-ASCII values should remain unchanged */
282+
}
283+
284+
/* Test unit for toUpperCase */
285+
static void TC_toUpperCase(void)
286+
{
287+
/* Test all lowercase letters */
288+
for (int i = 'a'; i <= 'z'; i++) {
289+
uassert_int_equal(toUpperCase(i), i - ('a' - 'A')); /* a-z should convert to A-Z */
290+
}
291+
292+
/* Test uppercase letters and non-alphabetic characters */
293+
for (int i = 0; i <= 127; i++) {
294+
if (i >= 'A' && i <= 'Z') {
295+
uassert_int_equal(toUpperCase(i), i); /* A-Z should remain unchanged */
296+
}
297+
if (i < 'A' || (i > 'Z' && i < 'a') || i > 'z') {
298+
uassert_int_equal(toUpperCase(i), i); /* Non-alphabetic should remain unchanged */
299+
}
300+
}
301+
302+
/* Test non-ASCII values */
303+
uassert_int_equal(toUpperCase(128), 128); /* Non-ASCII values should remain unchanged */
304+
}
305+
306+
/* Utest function to run all test cases */
307+
static void utest_do_tc(void)
308+
{
309+
UTEST_UNIT_RUN(TC_isAlphaNumeric);
310+
UTEST_UNIT_RUN(TC_isAlpha);
311+
UTEST_UNIT_RUN(TC_isAscii);
312+
UTEST_UNIT_RUN(TC_isWhitespace);
313+
UTEST_UNIT_RUN(TC_isControl);
314+
UTEST_UNIT_RUN(TC_isDigit);
315+
UTEST_UNIT_RUN(TC_isGraph);
316+
UTEST_UNIT_RUN(TC_isLowerCase);
317+
UTEST_UNIT_RUN(TC_isPrintable);
318+
UTEST_UNIT_RUN(TC_isPunct);
319+
UTEST_UNIT_RUN(TC_isSpace);
320+
UTEST_UNIT_RUN(TC_isUpperCase);
321+
UTEST_UNIT_RUN(TC_isHexadecimalDigit);
322+
UTEST_UNIT_RUN(TC_toAscii);
323+
UTEST_UNIT_RUN(TC_toLowerCase);
324+
UTEST_UNIT_RUN(TC_toUpperCase);
325+
}
326+
327+
UTEST_TC_EXPORT(utest_do_tc, "RTduino.core.WCharacter", RT_NULL, RT_NULL, 1000);

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.