| /* |
| * Copyright (c) 2017 MediaTek Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files |
| * (the "Software"), to deal in the Software without restriction, |
| * including without limitation the rights to use, copy, modify, merge, |
| * publish, distribute, sublicense, and/or sell copies of the Software, |
| * and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| #include <err.h> |
| #include <mtk_wrapper.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unittest.h> |
| #include <platform.h> |
| |
| /** |
| * lib/unittest defines several macros for unittest, |
| * EXPECT_EQ, EXPECT_NEQ, EXPECT_LE, EXPECT_LT, EXPECT_GE, EXPECT_GT, |
| * EXPECT_TRUE, EXPECT_FALSE, EXPECT_BYTES_EQ, EXPECT_BYTES_NE, EXPECT_EQ_LL, |
| * ASSERT_NOT_NULL. |
| * For detail, please refer to lib/unittest/include/unittest.h |
| */ |
| //irq function unittest |
| bool timerEnable = false; |
| #define ARM_GENERIC_TIMER_PHYSICAL_INT 30 |
| |
| static enum wrap_handler_return wrap_plat_platform_timer_handle(void *arg) |
| { |
| timerEnable = true; |
| plat_wrap_mask_interrupt(ARM_GENERIC_TIMER_PHYSICAL_INT); |
| return WRAP_INT_NO_RESCHEDULE; |
| } |
| |
| static bool test_plat_wrap_irq_function(void) |
| { |
| #define WRAP_LEVEL_SENSITIVE 1 |
| #define WRAP_POLARITY_LOW 0 |
| int count = 5; |
| |
| plat_wrap_irq_set_polarity(ARM_GENERIC_TIMER_PHYSICAL_INT, WRAP_LEVEL_SENSITIVE); |
| plat_wrap_irq_set_sensitive(ARM_GENERIC_TIMER_PHYSICAL_INT, WRAP_POLARITY_LOW); |
| plat_wrap_register_int_handler(ARM_GENERIC_TIMER_PHYSICAL_INT, &wrap_plat_platform_timer_handle, NULL); |
| plat_wrap_unmask_interrupt(ARM_GENERIC_TIMER_PHYSICAL_INT); |
| while (1) { |
| if (count > 0) { |
| plat_wrap_delay(1000000); |
| if (timerEnable) { |
| break; |
| } |
| count --; |
| } else |
| return false; |
| } |
| |
| return true; |
| } |
| |
| //delay function unittest |
| static bool test_plat_wrap_delay_function(void) |
| { |
| BEGIN_TEST; |
| |
| unsigned long long startTime = 0; |
| unsigned long long endTime = 0; |
| int delayTime = 1000000; //one second |
| int delayThreshold = 500; |
| |
| startTime = current_time_hires(); |
| plat_wrap_delay(1000000); |
| endTime = current_time_hires(); |
| EXPECT_LE((delayTime - delayThreshold), endTime - startTime, "delay time is less than expected value"); |
| EXPECT_GE((delayTime + delayThreshold), endTime - startTime, "delay time is greater than expected value"); |
| |
| END_TEST; |
| } |
| |
| //address translate function unittest |
| static bool test_plat_wrap_addr_trans_function(void) |
| { |
| #define EMI_PHY_BASE (0x10203000) |
| |
| BEGIN_TEST; |
| |
| unsigned long paddr; |
| void *vaddr = plat_wrap_paddr_to_kvaddr(EMI_PHY_BASE); |
| paddr = plat_wrap_kvaddr_to_paddr(vaddr); |
| EXPECT_EQ(EMI_PHY_BASE, paddr, "fail to virtual/phyical address translate"); |
| |
| END_TEST; |
| } |
| |
| //mutex function unittest |
| wrap_mutex m; |
| |
| static bool test_plat_wrap_mutex_function(void) |
| { |
| BEGIN_TEST; |
| |
| plat_wrap_mutex_init(&m); |
| EXPECT_EQ(NO_ERROR, plat_wrap_mutex_acquire(&m), "fail to mutex acquire"); |
| EXPECT_EQ(NO_ERROR, plat_wrap_mutex_release(&m), "fail to mutex release"); |
| plat_wrap_mutex_destroy(&m); |
| |
| END_TEST; |
| } |
| |
| //semphore function unittest |
| wrap_sem sem; |
| static bool test_plat_wrap_sem_function(void) |
| { |
| BEGIN_TEST; |
| |
| unsigned int value = 1; |
| plat_wrap_sem_init(&sem, value); |
| EXPECT_EQ(NO_ERROR, plat_wrap_sem_wait(&sem), "fail to semaphore wait function"); |
| EXPECT_EQ(NO_ERROR, plat_wrap_sem_post(&sem), "fail to semaphore post function"); |
| plat_wrap_sem_destroy(&sem); |
| |
| END_TEST; |
| } |
| |
| static bool test_plat_wrap_sem_trywait_function(void) |
| { |
| BEGIN_TEST; |
| |
| unsigned int value = 1; |
| plat_wrap_sem_init(&sem, value); |
| EXPECT_EQ(NO_ERROR, plat_wrap_sem_trywait(&sem), "fail to semaphore trywait function"); |
| EXPECT_EQ(NO_ERROR, plat_wrap_sem_post(&sem), "fail to semaphore post function"); |
| plat_wrap_sem_destroy(&sem); |
| |
| END_TEST; |
| } |
| |
| static bool test_plat_wrap_sem_timedwait_function(void) |
| { |
| BEGIN_TEST; |
| |
| unsigned int value = 1; |
| uint32_t timeout = 1; |
| plat_wrap_sem_init(&sem, value); |
| EXPECT_EQ(NO_ERROR, plat_wrap_sem_timedwait(&sem, timeout), "fail to semaphore timedwait function"); |
| EXPECT_EQ(NO_ERROR, plat_wrap_sem_post(&sem), "fail to semaphore post function"); |
| plat_wrap_sem_destroy(&sem); |
| |
| END_TEST; |
| } |
| |
| BEGIN_TEST_CASE(wrapper_tests); |
| RUN_TEST(test_plat_wrap_irq_function); |
| RUN_TEST(test_plat_wrap_delay_function); |
| RUN_TEST(test_plat_wrap_addr_trans_function); |
| RUN_TEST(test_plat_wrap_mutex_function); |
| RUN_TEST(test_plat_wrap_sem_function); |
| RUN_TEST(test_plat_wrap_sem_trywait_function); |
| RUN_TEST(test_plat_wrap_sem_timedwait_function); |
| END_TEST_CASE(wrapper_tests); |