diff --git a/testsuites/unittest/xts/BUILD.gn b/testsuites/unittest/xts/BUILD.gn index 688315e3..e5751833 100644 --- a/testsuites/unittest/xts/BUILD.gn +++ b/testsuites/unittest/xts/BUILD.gn @@ -30,6 +30,9 @@ import("//kernel/liteos_m/liteos.gni") static_library("xts_test") { sources = [ "xts_test.c" ] - deps = [ "ipc:ipc_test" ] + deps = [ + "io:io_test", + "ipc:ipc_test", + ] configs += [ "$LITEOSTOPDIR/testsuites:include" ] } diff --git a/testsuites/unittest/xts/io/BUILD.gn b/testsuites/unittest/xts/io/BUILD.gn new file mode 100644 index 00000000..38b28e07 --- /dev/null +++ b/testsuites/unittest/xts/io/BUILD.gn @@ -0,0 +1,46 @@ +# Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be used +# to endorse or promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import("//kernel/liteos_m/liteos.gni") + +static_library("io_test") { + sources = [ + "xts_io.c", + "xts_io_other_test.c", + "xts_io_stdio_test.c", + "xts_io_stdlib_test.c", + "xts_io_string_test.c", + "xts_io_strings_test.c", + ] + + include_dirs = [ + ".", + "$LITEOSTOPDIR/testsuites/include", + "$LITEOSTOPDIR/testsuites/unittest/xts", + ] +} diff --git a/testsuites/unittest/xts/io/xts_io.c b/testsuites/unittest/xts/io/xts_io.c new file mode 100644 index 00000000..dd607ffc --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io.c @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "xts_test.h" + +void IoFuncTest(void) +{ + XtsIoOtherTest(); + XtsIoStdioFuncTest(); + XtsIoStdlibFuncTest(); + XtsIoStringFuncTest(); + XtsIoStringsFuncTest(); +} \ No newline at end of file diff --git a/testsuites/unittest/xts/io/xts_io.h b/testsuites/unittest/xts/io/xts_io.h new file mode 100644 index 00000000..e716e927 --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef XTS_IO_H +#define XTS_IO_H + +#include "xts_test.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/testsuites/unittest/xts/io/xts_io_other_test.c b/testsuites/unittest/xts/io/xts_io_other_test.c new file mode 100644 index 00000000..23a33741 --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io_other_test.c @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "xts_io.h" + +LITE_TEST_SUIT(IO, IoOther, IoOtherTestSuite); + +static BOOL IoOtherTestSuiteSetUp(void) +{ + return TRUE; +} + +static BOOL IoOtherTestSuiteTearDown(void) +{ + return TRUE; +} + +/** + * @tc.number SUB_KERNEL_IO_OTHER_0900 + * @tc.name strptime basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoOtherTestSuite, testStrptime, Function | MediumTest | Level1) +{ + struct tm tm; + memset_s(&tm, sizeof(struct tm), 0, sizeof(struct tm)); + char *ret = strptime("2020-10-29 21:24:00abc", "%Y-%m-%d %H:%M:%S", &tm); + ICUNIT_ASSERT_STRING_EQUAL(ret, "abc", ret); + ICUNIT_ASSERT_EQUAL(tm.tm_year, 120, tm.tm_year); /* 120 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_mon, 9, tm.tm_mon); /* 9 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_mday, 29, tm.tm_mday); /* 29 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_hour, 21, tm.tm_hour); /* 21 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_min, 24, tm.tm_min); /* 24 common data for test, no special meaning */ + + ret = strptime("14 Oct October 20 09:24:00 Sat Saturday 363", "%d %b %B %y %I:%M:%S %a %A %j", &tm); + ICUNIT_ASSERT_STRING_EQUAL(ret, "", ret); + ICUNIT_ASSERT_EQUAL(tm.tm_year, 120, tm.tm_year); /* 120 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_mon, 9, tm.tm_mon); /* 9 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_mday, 14, tm.tm_mday); /* 14 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_hour, 9, tm.tm_hour); /* 9 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_wday, 6, tm.tm_wday); /* 6 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(tm.tm_yday, 362, tm.tm_yday); /* 362 common data for test, no special meaning */ + return 0; +} + +RUN_TEST_SUITE(IoOtherTestSuite); + +void XtsIoOtherTest(void) +{ + RUN_ONE_TESTCASE(testStrptime); +} diff --git a/testsuites/unittest/xts/io/xts_io_stdio_test.c b/testsuites/unittest/xts/io/xts_io_stdio_test.c new file mode 100644 index 00000000..5de79212 --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io_stdio_test.c @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "xts_io.h" + +LITE_TEST_SUIT(IO, IoStdio, IoStdioTestSuite); + +static BOOL IoStdioTestSuiteSetUp(void) +{ + return TRUE; +} + +static BOOL IoStdioTestSuiteTearDown(void) +{ + return TRUE; +} + +int FormatVsnptf(char *format, ...) +{ + va_list vArgList; + va_start(vArgList, format); + char str[50] = {0}; /* 50 common data for test, no special meaning */ + int ret = vsnprintf_s(str, sizeof(str), sizeof(str), format, vArgList); + va_end(vArgList); + return ret; +} + +/** + * @tc.number SUB_KERNEL_IO_STDIO_2100 + * @tc.name vsnprintf basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdioTestSuite, testVsnprintf, Function | MediumTest | Level1) +{ + int ret = FormatVsnptf((char *)"%s has %d words", "hello world", 11); /* 11 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 24, ret); /* 24 common data for test, no special meaning */ + + ret = FormatVsnptf((char *)"%f and %c as well as %ld\n", 2.2, 'c', 6); /* 2.2, 6 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 28, ret); /* 28 common data for test, no special meaning */ + return 0; +} + +RUN_TEST_SUITE(IoStdioTestSuite); + +void XtsIoStdioFuncTest(void) +{ + RUN_ONE_TESTCASE(testVsnprintf); +} diff --git a/testsuites/unittest/xts/io/xts_io_stdlib_test.c b/testsuites/unittest/xts/io/xts_io_stdlib_test.c new file mode 100644 index 00000000..e2ad211f --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io_stdlib_test.c @@ -0,0 +1,282 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "xts_io.h" + +LITE_TEST_SUIT(IO, IoStdlibApi, IoStdlibApiTestSuite); + +static BOOL IoStdlibApiTestSuiteSetUp(void) +{ + return TRUE; +} + +static BOOL IoStdlibApiTestSuiteTearDown(void) +{ + return TRUE; +} + +/** + * @tc.number SUB_KERNEL_IO_STDLIB_0400 + * @tc.name strtof basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdlibApiTestSuite, testStrtof, Function | MediumTest | Level1) +{ + char *endPtr = NULL; + float ret = strtof(" -3.40E+38 hello", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, (float)(-3.40E+38), ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " hello", endPtr); + + ret = strtof(" 3.40E+38 ===", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, (float)(3.40E+38), ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " ===", endPtr); + + ret = strtof("-9.6e17 this 123", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, (float)(-9.6e17), ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " this 123", endPtr); + + ret = strtof("this is string", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, "this is string", endPtr); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STDLIB_0500 + * @tc.name strtod basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdlibApiTestSuite, testStrtod, Function | MediumTest | Level1) +{ + char *endPtr = NULL; + double ret = strtod(" -1.79E+308 hello", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, -1.79E+308, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " hello", endPtr); + + ret = strtod("1.79E+308 ===", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, 1.79E+308, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " ===", endPtr); + + ret = strtod("-9.6e17 this 123", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, -9.6e17, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " this 123", endPtr); + + ret = strtod("this is string", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, "this is string", endPtr); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STDLIB_0600 + * @tc.name strtold basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdlibApiTestSuite, testStrtold, Function | MediumTest | Level1) +{ + char *endPtr = NULL; + long double ret = strtold(" 2.22507e-308 hello", &endPtr); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " hello", endPtr); + + ret = strtold(" 1.79769e+308 ===", &endPtr); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " ===", endPtr); + + ret = strtold("-9.6e17 this 123", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, -9.6e17, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " this 123", endPtr); + + ret = strtold("this is string", &endPtr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, "this is string", endPtr); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STDLIB_0700 + * @tc.name strtol basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdlibApiTestSuite, testStrtol, Function | MediumTest | Level1) +{ + char nPtr[] = "12 0110 0XDEFE 0666 -1.6"; + char *endPtr = NULL; + long ret = strtol(nPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 12, ret); /* 12 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0110 0XDEFE 0666 -1.6", endPtr); + + ret = strtol(endPtr, &endPtr, 2); /* 2 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 6, ret); /* 6 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0XDEFE 0666 -1.6", endPtr); + + ret = strtol(endPtr, &endPtr, 16); /* 16 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0XDEFE, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0666 -1.6", endPtr); + + ret = strtol(endPtr, &endPtr, 8); /* 8 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0666, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " -1.6", endPtr); + + ret = strtol(endPtr, &endPtr, 65); /* 65 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " -1.6", endPtr); + + ret = strtol(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, -1, ret); /* -1 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".6", endPtr); + + ret = strtol(endPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".6", endPtr); + + char nPtr1[] = "2147483647 2147483648 -2147483648 -2147483649"; + ret = strtol(nPtr1, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 2147483647, ret); /* 2147483647 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 2147483648 -2147483648 -2147483649", endPtr); + + ret = strtol(endPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 2147483647, ret); /* 2147483647 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " -2147483648 -2147483649", endPtr); + + ret = strtol(endPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, -2147483648, ret); /* -2147483648 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " -2147483649", endPtr); + + ret = strtol(endPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, -2147483648, ret); /* -2147483648 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(endPtr, "", endPtr); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STDLIB_0800 + * @tc.name strtoul basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdlibApiTestSuite, testStrtoul, Function | MediumTest | Level1) +{ + char nPtr[] = "12 0110 0XDEFE 0666 4294967295 4294967296 12.34"; + char *endPtr = NULL; + unsigned long ret = strtoul(nPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 12UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0110 0XDEFE 0666 4294967295 4294967296 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 2); /* 2 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 6UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0XDEFE 0666 4294967295 4294967296 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 16); /* 16 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0XDEFEUL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0666 4294967295 4294967296 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 8); /* 8 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0666UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 4294967295 4294967296 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, 4294967295UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 4294967296 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, 4294967295UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 65); /* 65 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 12.34", endPtr); + + ret = strtoul(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, 12UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".34", endPtr); + + ret = strtoul(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, 0UL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".34", endPtr); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STDLIB_1000 + * @tc.name strtoull basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStdlibApiTestSuite, testStrtoull, Function | MediumTest | Level1) +{ + char nPtr[] = "12 0110 0XDEFE 0666 1.6"; + char *endPtr = NULL; + unsigned long long ret = strtoull(nPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 12ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0110 0XDEFE 0666 1.6", endPtr); + + ret = strtoull(endPtr, &endPtr, 2); /* 2 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 6ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0XDEFE 0666 1.6", endPtr); + + ret = strtoull(endPtr, &endPtr, 16); /* 16 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0XDEFEULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 0666 1.6", endPtr); + + ret = strtoull(endPtr, &endPtr, 8); /* 8 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0666ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 1.6", endPtr); + + ret = strtoull(endPtr, &endPtr, 65); /* 65 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 1.6", endPtr); + + ret = strtoull(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, 1ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".6", endPtr); + + ret = strtoull(endPtr, &endPtr, 0); + ICUNIT_ASSERT_EQUAL(ret, 0ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, ".6", endPtr); + + char nPtr1[] = "18446744073709551615 18446744073709551616"; + ret = strtoull(nPtr1, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 18446744073709551615ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, " 18446744073709551616", endPtr); + + ret = strtoull(endPtr, &endPtr, 10); /* 10 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 18446744073709551615ULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(endPtr, "", endPtr); + return 0; +} + +RUN_TEST_SUITE(IoStdlibApiTestSuite); + +void XtsIoStdlibFuncTest(void) +{ + RUN_ONE_TESTCASE(testStrtof); + RUN_ONE_TESTCASE(testStrtod); + RUN_ONE_TESTCASE(testStrtold); + RUN_ONE_TESTCASE(testStrtol); + RUN_ONE_TESTCASE(testStrtoul); + RUN_ONE_TESTCASE(testStrtoull); +} diff --git a/testsuites/unittest/xts/io/xts_io_string_test.c b/testsuites/unittest/xts/io/xts_io_string_test.c new file mode 100644 index 00000000..263efa07 --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io_string_test.c @@ -0,0 +1,374 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "xts_io.h" + +LITE_TEST_SUIT(IO, IoStringApi, IoStringApiTestSuite); + +static BOOL IoStringApiTestSuiteSetUp(void) +{ + return TRUE; +} + +static BOOL IoStringApiTestSuiteTearDown(void) +{ + return TRUE; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_0300 + * @tc.name strcmp basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrcmp, Function | MediumTest | Level1) +{ + int ret = strcmp("abcdef", "ABCDEF"); + ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret); + + ret = strcmp("123456", "654321"); + ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret); + + ret = strcmp("~!@#$%^&*()_+", "~!@#$%^&*()_+"); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_0400 + * @tc.name strncmp basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrncmp, Function | MediumTest | Level1) +{ + const char dest[] = "abcdef"; + const char src[] = "ABCDEF"; + int ret = strncmp(dest, src, 1); /* 1 common data for test, no special meaning */ + ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret); + + ret = strncmp("123456", "654321", 6); /* 6 common data for test, no special meaning */ + ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret); + + ret = strncmp("~!@#$%^&*()_+", "~!@#$%^&*()_+", 8); /* 8 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_0700 + * @tc.name stpcpy basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStpcpy, Function | MediumTest | Level1) +{ + const char *src = "hello world !"; + char dest[50] = {0}; /* 50 common data for test, no special meaning */ + char *ret = stpcpy(dest, src); + ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(dest, src, dest); + + const char *srcT = "~!@#$%%^&*()_+"; + char destT[50] = {0}; /* 50 common data for test, no special meaning */ + ret = stpcpy(destT, srcT); + ICUNIT_ASSERT_NOT_EQUAL(ret, NULL, ret); + ICUNIT_ASSERT_STRING_EQUAL(destT, srcT, destT); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_0800 + * @tc.name stpncpy basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStpncpy, Function | MediumTest | Level1) +{ + char src[] = "hello world !"; + char dest[50] = {0}; /* 50 common data for test, no special meaning */ + char *ret = stpncpy(dest, src, 5); /* 5 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(ret, "", ret); + ICUNIT_ASSERT_STRING_EQUAL(dest, "hello", dest); + + char srcT[] = "~!@#$%%^&*()_+"; + char destT[50] = {0}; /* 50 common data for test, no special meaning */ + ret = stpncpy(destT, srcT, 15); /* 15 common data for test, no special meaning */ + ICUNIT_ASSERT_STRING_EQUAL(ret, "", ret); + ICUNIT_ASSERT_STRING_EQUAL(destT, "~!@#$%%^&*()_+", destT); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1000 + * @tc.name strcpy basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrcpy, Function | MediumTest | Level1) +{ + char src[] = "hello world !"; + char dest[20] = {0}; /* 20 common data for test, no special meaning */ + int ret = strcpy_s(dest, sizeof(dest), src); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + char srcT[] = "This is String1"; + char destT[20] = {0}; /* 20 common data for test, no special meaning */ + ret = strcpy_s(destT, sizeof(destT), srcT); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1100 + * @tc.name strncpy basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrncpy, Function | MediumTest | Level1) +{ + char src[] = "hello world !"; + char dest[20] = {0}; + int ret = strncpy_s(dest, sizeof(dest), src, 6); /* 6 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + char destT[] = "~!@#$%^&*()_+"; + ret = strncpy_s(destT, sizeof(destT), "hello world", 0); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1400 + * @tc.name strcat basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrcat, Function | MediumTest | Level1) +{ + char dest[50] = {0}; /* 50 common data for test, no special meaning */ + int ret = strcat_s(dest, sizeof(dest), "hello world !"); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + char destT[50] = "hello world ! || "; /* 50 common data for test, no special meaning */ + ret = strcat_s(destT, sizeof(destT), "This is String1"); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1500 + * @tc.name strncat basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrncat, Function | MediumTest | Level1) +{ + char dest[50] = "hello world || "; /* 50 common data for test, no special meaning */ + int ret = strncat_s(dest, sizeof(dest), "This is String1", 7); /* 7 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + char destT[20] = "|/*"; /* 20 common data for test, no special meaning */ + ret = strncat_s(destT, sizeof(destT), "~!@#$%^&*()_+", 13); /* 13 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1600 + * @tc.name strchr basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrchr, Function | MediumTest | Level1) +{ + char src[] = "hello !! world"; + char *ret = strchr(src, '!'); + ICUNIT_ASSERT_STRING_EQUAL(ret, "!! world", ret); + + ret = strchr(src, '?'); + ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1700 + * @tc.name strrchr basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrrchr, Function | MediumTest | Level1) +{ + char src[] = "hello world & HEELO & WORLD"; + char *ret = strrchr(src, '&'); + ICUNIT_ASSERT_STRING_EQUAL(ret, "& WORLD", ret); + + ret = strrchr(src, '?'); + ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1800 + * @tc.name strnlen basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrnlen, Function | MediumTest | Level1) +{ + char src[] = "hello world !"; + unsigned int ltSrcSize = strlen(src) - 2; /* 2 common data for test, no special meaning */ + unsigned int gtSrcSize = strlen(src) + 2; /* 2 common data for test, no special meaning */ + + size_t ret = strnlen(src, ltSrcSize); + ICUNIT_ASSERT_EQUAL(ret, ltSrcSize, ret); + + ret = strnlen(src, gtSrcSize); + ICUNIT_ASSERT_EQUAL(ret, strlen(src), ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_1900 + * @tc.name strtok basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrtok, Function | MediumTest | Level1) +{ + char src[] = "hello world & This is-String1"; + char *ret = strtok(src, "&"); + ICUNIT_ASSERT_STRING_EQUAL(ret, src, ret); + + ret = strtok(NULL, "-"); + ICUNIT_ASSERT_STRING_EQUAL(ret, " This is", ret); + + char srcS[] = "hello world !"; + ret = strtok(srcS, "?"); + ICUNIT_ASSERT_STRING_EQUAL(ret, srcS, ret); + + char srcT[50] = {0}; /* 50 common data for test, no special meaning */ + ret = strtok(srcT, "~"); + ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_2200 + * @tc.name strdup basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrdup, Function | MediumTest | Level1) +{ + char src[] = "hello world !"; + char *ret = strdup(src); + ICUNIT_ASSERT_STRING_EQUAL(ret, src, ret); + + char srcS[] = "This is String1"; + ret = strdup(srcS); + ICUNIT_ASSERT_STRING_EQUAL(ret, "This is String1", ret); + free(ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_2500 + * @tc.name strcspn basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrcspn, Function | MediumTest | Level1) +{ + const char dest[] = "hello world !"; + const char src[] = "!"; + size_t ret = strcspn(dest, src); + ICUNIT_ASSERT_EQUAL(ret, 12U, ret); + + const char srcS[] = "a"; + ret = strcspn(dest, srcS); + ICUNIT_ASSERT_EQUAL(ret, 13U, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_2600 + * @tc.name strspn basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrspn, Function | MediumTest | Level1) +{ + const char dest[] = "hello world !"; + const char src[] = "heAlo"; + size_t ret = strspn(dest, src); + ICUNIT_ASSERT_EQUAL(ret, 5U, ret); + ICUNIT_ASSERT_EQUAL(ret, 5U, ret); + + const char destS[] = "this is string"; + const char srcS[] = "abc"; + ret = strspn(destS, srcS); + ICUNIT_ASSERT_EQUAL(ret, 0U, ret); + + const char srcT[] = "helo\0 wal"; + ret = strspn(dest, srcT); + ICUNIT_ASSERT_EQUAL(ret, 5U, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRING_2700 + * @tc.name strstr basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringApiTestSuite, testStrstr, Function | MediumTest | Level1) +{ + const char dest[] = "hello world !"; + const char src[] = "heAlo"; + const char *ret = strstr(dest, src); + ICUNIT_ASSERT_STRING_EQUAL(ret, NULL, ret); + + const char destS[] = "string this is string"; + const char srcS[] = "string"; + ret = strstr(destS, srcS); + ICUNIT_ASSERT_STRING_EQUAL(ret, "string this is string", ret); + + const char srcT[] = "\0hello"; + ret = strstr(dest, srcT); + ICUNIT_ASSERT_STRING_EQUAL(ret, "hello world !", ret); + return 0; +} + +RUN_TEST_SUITE(IoStringApiTestSuite); + +void XtsIoStringFuncTest(void) +{ + RUN_ONE_TESTCASE(testStrcmp); + RUN_ONE_TESTCASE(testStrncmp); + RUN_ONE_TESTCASE(testStpcpy); + RUN_ONE_TESTCASE(testStpncpy); + RUN_ONE_TESTCASE(testStrcpy); + RUN_ONE_TESTCASE(testStrncpy); + RUN_ONE_TESTCASE(testStrcat); + RUN_ONE_TESTCASE(testStrncat); + RUN_ONE_TESTCASE(testStrchr); + RUN_ONE_TESTCASE(testStrrchr); + RUN_ONE_TESTCASE(testStrnlen); + RUN_ONE_TESTCASE(testStrtok); + RUN_ONE_TESTCASE(testStrdup); + RUN_ONE_TESTCASE(testStrcspn); + RUN_ONE_TESTCASE(testStrspn); + RUN_ONE_TESTCASE(testStrstr); +} diff --git a/testsuites/unittest/xts/io/xts_io_strings_test.c b/testsuites/unittest/xts/io/xts_io_strings_test.c new file mode 100644 index 00000000..5fbf6aed --- /dev/null +++ b/testsuites/unittest/xts/io/xts_io_strings_test.c @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * 3. Neither the name of the copyright holder nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "xts_io.h" + +LITE_TEST_SUIT(IO, IoStringsApi, IoStringsApiTestSuite); + +static BOOL IoStringsApiTestSuiteSetUp(void) +{ + return TRUE; +} + +static BOOL IoStringsApiTestSuiteTearDown(void) +{ + return TRUE; +} + +/** + * @tc.number SUB_KERNEL_IO_STRINGS_0200 + * @tc.name strncasecmp basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringsApiTestSuite, testStrncasecmp, Function | MediumTest | Level1) +{ + int ret = strncasecmp("abcdefg", "abcdEFg", 7); /* 7 common data for test, no special meaning */ + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + ret = strncasecmp("abcdefg", "abcdEF", 7); /* 7 common data for test, no special meaning */ + ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret); + + ret = strncasecmp("abcdef", "abcdEFg", 7); /* 7 common data for test, no special meaning */ + ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret); + return 0; +} + +/** + * @tc.number SUB_KERNEL_IO_STRINGS_0300 + * @tc.name strcasecmp basic function test + * @tc.desc [C- SOFTWARE -0200] + */ +LITE_TEST_CASE(IoStringsApiTestSuite, testStrcasecmp, Function | MediumTest | Level2) +{ + int ret = strcasecmp("abcdefg", "abcdEFg"); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + ret = strcasecmp("abcdefg", "abcdEF"); + ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, INT_MAX, ret); + + ret = strcasecmp("abcdef", "abcdEFg"); + ICUNIT_ASSERT_WITHIN_EQUAL(ret, INT_MIN, 0, ret); + return 0; +} + +RUN_TEST_SUITE(IoStringsApiTestSuite); + +void XtsIoStringsFuncTest(void) +{ + RUN_ONE_TESTCASE(testStrncasecmp); + RUN_ONE_TESTCASE(testStrcasecmp); +} diff --git a/testsuites/unittest/xts/xts_test.c b/testsuites/unittest/xts/xts_test.c index edfeb2e6..85e61ee8 100644 --- a/testsuites/unittest/xts/xts_test.c +++ b/testsuites/unittest/xts/xts_test.c @@ -33,4 +33,5 @@ void XtsTestSuite(void) { IpcSemApiTest(); + IoFuncTest(); } diff --git a/testsuites/unittest/xts/xts_test.h b/testsuites/unittest/xts/xts_test.h index ff6d6915..3bec36cc 100644 --- a/testsuites/unittest/xts/xts_test.h +++ b/testsuites/unittest/xts/xts_test.h @@ -54,4 +54,6 @@ void XtsTestSuite(void); extern void IpcSemApiTest(void); +extern void IoFuncTest(void); + #endif