From f3d606b6dded4942e74dfb349ca785c2b38fd0ae Mon Sep 17 00:00:00 2001 From: yinjiaming Date: Sun, 9 Oct 2022 11:59:09 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20POSIX=E6=B5=8B=E8=AF=95=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E5=90=8E=E7=BB=AD=E8=A1=A5=E5=85=85=20=E3=80=90?= =?UTF-8?q?=E8=83=8C=E6=99=AF=E3=80=91=20posix=20=E6=B5=8B=E8=AF=95?= =?UTF-8?q?=E7=94=A8=E4=BE=8B=E8=A1=A5=E5=85=85?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 【修改方案】 继续将A核 相关POSIX测试用例移植到 M核 【影响】 对现有的产品编译不会有影响。 Signed-off-by: yinjiaming Change-Id: I91f996a4b4db47a417c9f32c9e04924cc264afbb --- testsuites/sample/posix/BUILD.gn | 8 ++ .../sample/posix/pthread/It_posix_pthread.c | 8 ++ .../posix/pthread/It_posix_pthread_009.c | 66 +++++++++ .../posix/pthread/It_posix_pthread_010.c | 59 ++++++++ .../posix/pthread/It_posix_pthread_011.c | 63 +++++++++ .../posix/pthread/It_posix_pthread_012.c | 75 ++++++++++ .../posix/pthread/It_posix_pthread_013.c | 132 ++++++++++++++++++ .../posix/pthread/It_posix_pthread_014.c | 73 ++++++++++ .../posix/pthread/It_posix_pthread_015.c | 52 +++++++ .../posix/pthread/It_posix_pthread_016.c | 56 ++++++++ 10 files changed, 592 insertions(+) create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_009.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_010.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_011.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_012.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_013.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_014.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_015.c create mode 100644 testsuites/sample/posix/pthread/It_posix_pthread_016.c diff --git a/testsuites/sample/posix/BUILD.gn b/testsuites/sample/posix/BUILD.gn index 0c42a4b7..ac7ac1b1 100644 --- a/testsuites/sample/posix/BUILD.gn +++ b/testsuites/sample/posix/BUILD.gn @@ -37,6 +37,14 @@ static_library("test_posix") { "pthread/It_posix_pthread_006.c", "pthread/It_posix_pthread_007.c", "pthread/It_posix_pthread_008.c", + "pthread/It_posix_pthread_009.c", + "pthread/It_posix_pthread_010.c", + "pthread/It_posix_pthread_011.c", + "pthread/It_posix_pthread_012.c", + "pthread/It_posix_pthread_013.c", + "pthread/It_posix_pthread_014.c", + "pthread/It_posix_pthread_015.c", + "pthread/It_posix_pthread_016.c", "pthread_func_test.c", ] diff --git a/testsuites/sample/posix/pthread/It_posix_pthread.c b/testsuites/sample/posix/pthread/It_posix_pthread.c index 2db8cc53..ba84ab3c 100644 --- a/testsuites/sample/posix/pthread/It_posix_pthread.c +++ b/testsuites/sample/posix/pthread/It_posix_pthread.c @@ -54,4 +54,12 @@ VOID ItSuitePosixPthread() ItPosixPthread006(); ItPosixPthread007(); ItPosixPthread008(); + ItPosixPthread009(); + ItPosixPthread010(); + ItPosixPthread011(); + ItPosixPthread012(); + ItPosixPthread013(); + ItPosixPthread014(); + ItPosixPthread015(); + ItPosixPthread016(); } diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_009.c b/testsuites/sample/posix/pthread/It_posix_pthread_009.c new file mode 100644 index 00000000..82d0e34c --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_009.c @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + pthread_condattr_t condattr; + int rc; + + /* Initialize a condition variable attributes object */ + rc = pthread_condattr_init(&condattr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + /* Destroy the condition variable attributes object */ + rc = pthread_condattr_destroy(&condattr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + /* Initialize the condition variable attributes object again. This shouldn't result in an error. */ + rc = pthread_condattr_init(&condattr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + rc = pthread_condattr_destroy(&condattr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread009 + * @tc.desc: Test interface pthread_condattr_destroy + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread009(VOID) +{ + TEST_ADD_CASE("ItPosixPthread009", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_010.c b/testsuites/sample/posix/pthread/It_posix_pthread_010.c new file mode 100644 index 00000000..7ba16f72 --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_010.c @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2020-2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + pthread_condattr_t *condattr = NULL; + int rc; + + /* Initialize a condition variable attributes object */ + rc = pthread_condattr_init(condattr); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + /* Destroy the condition variable attributes object */ + rc = pthread_condattr_destroy(condattr); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread010 + * @tc.desc: Test interface pthread_condattr_init + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread010(VOID) +{ + TEST_ADD_CASE("ItPosixPthread010", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_011.c b/testsuites/sample/posix/pthread/It_posix_pthread_011.c new file mode 100644 index 00000000..07a2bce9 --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_011.c @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2020-2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + pthread_condattr_t attr; + int ret; + + /* Initialize a cond attributes object */ + ret = pthread_condattr_init(&attr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + /* Set 'pshared' to INVALID_PSHARED_VALUE. */ + ret = pthread_condattr_setpshared(&attr, INVALID_PSHARED_VALUE); + ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret); + + /* Destroy the cond attributes object */ + ret = pthread_condattr_destroy(&attr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread011 + * @tc.desc: Test interface pthread_condattr_setpshared + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread011(VOID) +{ + TEST_ADD_CASE("ItPosixPthread011", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_012.c b/testsuites/sample/posix/pthread/It_posix_pthread_012.c new file mode 100644 index 00000000..d6eea653 --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_012.c @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + INT32 ret; + INT32 inheritsched; + INT32 g_pthreadSchedInherit; + pthread_attr_t attr; + + ret = pthread_attr_init(&attr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + g_pthreadSchedInherit = PTHREAD_INHERIT_SCHED; + ret = pthread_attr_setinheritsched(&attr, g_pthreadSchedInherit); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + ret = pthread_attr_getinheritsched(&attr, &inheritsched); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_EQUAL(inheritsched, g_pthreadSchedInherit, inheritsched); + + g_pthreadSchedInherit = PTHREAD_EXPLICIT_SCHED; + ret = pthread_attr_setinheritsched(&attr, g_pthreadSchedInherit); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + ret = pthread_attr_getinheritsched(&attr, &inheritsched); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + ICUNIT_ASSERT_EQUAL(inheritsched, g_pthreadSchedInherit, inheritsched); + + ret = pthread_attr_destroy(&attr); + ICUNIT_ASSERT_EQUAL(ret, 0, ret); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread012 + * @tc.desc: Test interface pthread_attr_getinheritsched + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread012(VOID) +{ + TEST_ADD_CASE("ItPosixPthread012", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_013.c b/testsuites/sample/posix/pthread/It_posix_pthread_013.c new file mode 100644 index 00000000..4c493c10 --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_013.c @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2020-2022 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 "It_posix_pthread.h" + +#define LOOP_NUM 2 +static pthread_mutex_t g_pthreadMutexTest1 = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t g_pthreadCondTest1 = PTHREAD_COND_INITIALIZER; + +static VOID *PthreadF01(void *t) +{ + int rc; + + rc = pthread_mutex_lock(&g_pthreadMutexTest1); + ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + + g_testCount++; + LOS_TaskDelay(1); + ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 2, here assert the result. + g_testCount++; + + rc = pthread_cond_wait(&g_pthreadCondTest1, &g_pthreadMutexTest1); + ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + + ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 5, here assert the result. + rc = pthread_mutex_unlock(&g_pthreadMutexTest1); + ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + +EXIT: + return NULL; +} + +static VOID *PthreadF02(void *t) +{ + int i; + int rc; + + ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); + g_testCount++; + rc = pthread_mutex_lock(&g_pthreadMutexTest1); + ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + + ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 3, here assert the result. + g_testCount++; + rc = pthread_cond_signal(&g_pthreadCondTest1); + ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + + ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 4, here assert the result. + g_testCount++; + + rc = pthread_mutex_unlock(&g_pthreadMutexTest1); /* Increase latency for thread polling mutex */ + ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + LOS_TaskDelay(2); // 2, delay for Timing control. + +EXIT: + return NULL; +} +static UINT32 Testcase(VOID) +{ + int i; + long t1 = 1; + long t2 = 2; // 2, init + int rc; + pthread_t threads[3]; // 3, need 3 pthread for test. + pthread_attr_t attr; + + g_testCount = 0; + pthread_mutex_init(&g_pthreadMutexTest1, NULL); + /* When creating thread, it is set to connectable state, which is easy to transplant */ + pthread_cond_init(&g_pthreadCondTest1, NULL); + pthread_attr_init(&attr); + + rc = pthread_create(&threads[0], &attr, PthreadF01, (void *)t1); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + rc = pthread_create(&threads[1], &attr, PthreadF02, (void *)t2); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + for (i = 0; i < LOOP_NUM; i++) { + rc = pthread_join(threads[i], NULL); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + } + + rc = pthread_attr_destroy(&attr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + rc = pthread_mutex_destroy(&g_pthreadMutexTest1); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + rc = pthread_cond_destroy(&g_pthreadCondTest1); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread013 + * @tc.desc: Test interface pthread_mutex_init + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread013(VOID) +{ + TEST_ADD_CASE("ItPosixPthread013", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_014.c b/testsuites/sample/posix/pthread/It_posix_pthread_014.c new file mode 100644 index 00000000..d7a764aa --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_014.c @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + pthread_condattr_t condattr; + pthread_cond_t cond1; + pthread_cond_t cond2; + int pshared; + int rc; + + rc = pthread_condattr_init(&condattr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + rc = pthread_condattr_getpshared(NULL, &pshared); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + rc = pthread_condattr_getpshared(&condattr, NULL); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + rc = pthread_condattr_getpshared(NULL, NULL); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + rc = pthread_condattr_getpshared(&condattr, &pshared); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + ICUNIT_ASSERT_EQUAL(pshared, PTHREAD_PROCESS_PRIVATE, pshared); + + rc = pthread_condattr_destroy(&condattr); + ICUNIT_ASSERT_EQUAL(rc, 0, rc); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread014 + * @tc.desc: Test interface pthread_condattr_getpshared + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread014(VOID) +{ + TEST_ADD_CASE("ItPosixPthread014", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_015.c b/testsuites/sample/posix/pthread/It_posix_pthread_015.c new file mode 100644 index 00000000..e36d55ef --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_015.c @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + int rc; + + rc = pthread_cond_init(NULL, NULL); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread015 + * @tc.desc: Test interface pthread_cond_init + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread015(VOID) +{ + TEST_ADD_CASE("ItPosixPthread015", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +} diff --git a/testsuites/sample/posix/pthread/It_posix_pthread_016.c b/testsuites/sample/posix/pthread/It_posix_pthread_016.c new file mode 100644 index 00000000..c91a053c --- /dev/null +++ b/testsuites/sample/posix/pthread/It_posix_pthread_016.c @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2022 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 "It_posix_pthread.h" + +static UINT32 Testcase(VOID) +{ + int rc; + + rc = pthread_cond_signal(NULL); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + rc = pthread_cond_broadcast(NULL); + ICUNIT_ASSERT_EQUAL(rc, EINVAL, rc); + + return LOS_OK; +} + +/** + * @tc.name: ItPosixPthread016 + * @tc.desc: Test interface pthread_cond_signal + * @tc.type: FUNC + * @tc.require: issueI5TIRQ + */ + +VOID ItPosixPthread016(VOID) +{ + TEST_ADD_CASE("ItPosixPthread016", Testcase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); +}