Line data    Source code

       1           1 : /**
       2             :  * @file test/lp/lp_test.c
       3             :  *
       4             :  * @brief Test: logical process lifetime handler module
       5             :  *
       6             :  * SPDX-FileCopyrightText: 2008-2021 HPDCS Group <rootsim@googlegroups.com>
       7             :  * SPDX-License-Identifier: GPL-3.0-only
       8             :  */
       9             : #include <test.h>
      10             : 
      11             : #include <lp/lp.h>
      12             : 
      13           0 : #define N_LPS 90
      14           0 : #define N_THREADS 16
      15             : 
      16           0 : static int trm_calls[N_LPS];
      17           0 : static int proc_calls[N_LPS];
      18           0 : static int deinit_calls[N_LPS];
      19           0 : static int mmem_calls[N_LPS];
      20           0 : static int lib_calls[N_LPS];
      21           0 : static int wrapm_calls[N_LPS];
      22             : 
      23           0 : void *malloc_mt(size_t siz)
      24             : {
      25             :         (void) siz;
      26             :         wrapm_calls[current_lp - lps]++;
      27             :         return NULL;
      28             : }
      29             : 
      30           1 : bool sync_thread_barrier(void){ return test_thread_barrier();}
      31             : 
      32           0 : void termination_lp_init(void){ trm_calls[current_lp - lps]++;}
      33             : 
      34           1 : void process_lp_init(void){ proc_calls[current_lp - lps]++;}
      35           1 : void process_lp_fini(void){ proc_calls[current_lp - lps]--;}
      36             : 
      37           1 : void process_lp_deinit(void){ deinit_calls[current_lp - lps] += UCHAR_MAX;}
      38             : 
      39           0 : void model_allocator_lp_init(void){ mmem_calls[current_lp - lps]++;}
      40           0 : void model_allocator_lp_fini(void){ mmem_calls[current_lp - lps]--;}
      41             : 
      42           0 : void lib_lp_init_pr(void){ lib_calls[current_lp - lps]++;}
      43           0 : void lib_lp_fini_pr(void){ lib_calls[current_lp - lps]--;}
      44             : 
      45           0 : static int lp_test_init(void)
      46             : {
      47             :         n_lps = N_LPS;
      48             :         lp_global_init();
      49             :         return 0;
      50             : }
      51             : 
      52           0 : static int lp_test_fini(void)
      53             : {
      54             :         int ret = 0;
      55             :         for(unsigned i = 0; i < N_LPS; ++i){
      56             :                 ret += proc_calls[i] != 0;
      57             :                 ret += deinit_calls[i] != UCHAR_MAX;
      58             :                 ret += mmem_calls[i] != 0;
      59             :                 ret += lib_calls[i] != 0;
      60             :                 ret += trm_calls[i] != 1;
      61             :         }
      62             :         lp_global_fini();
      63             :         return ret;
      64             : }
      65             : 
      66           0 : static int lp_test(void)
      67             : {
      68             :         int ret = 0;
      69             :         lp_init();
      70             :         if(test_thread_barrier()){
      71             :                 for(unsigned i = 0; i < N_LPS; ++i){
      72             :                         ret += proc_calls[i] != 1;
      73             :                         ret += deinit_calls[i] != 0;
      74             :                         ret += mmem_calls[i] != 1;
      75             :                         ret += lib_calls[i] != 1;
      76             :                         ret += trm_calls[i] != 1;
      77             :                         ret += wrapm_calls[i] != 1;
      78             :                 }
      79             :         }
      80             :         test_thread_barrier();
      81             :         lp_fini();
      82             :         return ret;
      83             : }
      84             : 
      85             : 
      86             : const struct test_config test_config = {
      87             :         .threads_count = N_THREADS,
      88             :         .test_init_fnc = lp_test_init,
      89             :         .test_fini_fnc = lp_test_fini,
      90             :         .test_fnc = lp_test
      91             : };