int test_main(void) { pj_status_t rc; pj_caching_pool caching_pool; const char *filename; unsigned tsx_test_cnt=0; struct tsx_test_param tsx_test[10]; pj_status_t status; #if INCLUDE_TSX_TEST unsigned i; pjsip_transport *tp; #if PJ_HAS_TCP pjsip_tpfactory *tpfactory; #endif /* PJ_HAS_TCP */ #endif /* INCLUDE_TSX_TEST */ int line; pj_log_set_level(log_level); pj_log_set_decor(param_log_decor); if ((rc=pj_init()) != PJ_SUCCESS) { app_perror("pj_init", rc); return rc; } if ((rc=pjlib_util_init()) != PJ_SUCCESS) { app_perror("pj_init", rc); return rc; } status = init_report(); if (status != PJ_SUCCESS) return status; pj_dump_config(); pj_caching_pool_init( &caching_pool, &pj_pool_factory_default_policy, PJSIP_TEST_MEM_SIZE ); rc = pjsip_endpt_create(&caching_pool.factory, "endpt", &endpt); if (rc != PJ_SUCCESS) { app_perror("pjsip_endpt_create", rc); pj_caching_pool_destroy(&caching_pool); return rc; } PJ_LOG(3,(THIS_FILE,"")); /* Init logger module. */ init_msg_logger(); msg_logger_set_enabled(1); /* Start transaction layer module. */ rc = pjsip_tsx_layer_init_module(endpt); if (rc != PJ_SUCCESS) { app_perror(" Error initializing transaction module", rc); goto on_return; } /* Create loop transport. */ rc = pjsip_loop_start(endpt, NULL); if (rc != PJ_SUCCESS) { app_perror(" error: unable to create datagram loop transport", rc); goto on_return; } tsx_test[tsx_test_cnt].port = 5060; tsx_test[tsx_test_cnt].tp_type = "loop-dgram"; tsx_test[tsx_test_cnt].type = PJSIP_TRANSPORT_LOOP_DGRAM; ++tsx_test_cnt; #if INCLUDE_URI_TEST DO_TEST(uri_test()); #endif #if INCLUDE_MSG_TEST DO_TEST(msg_test()); DO_TEST(msg_err_test()); #endif #if INCLUDE_MULTIPART_TEST DO_TEST(multipart_test()); #endif #if INCLUDE_TXDATA_TEST DO_TEST(txdata_test()); #endif #if INCLUDE_TSX_BENCH DO_TEST(tsx_bench()); #endif #if INCLUDE_UDP_TEST DO_TEST(transport_udp_test()); #endif #if INCLUDE_LOOP_TEST DO_TEST(transport_loop_test()); #endif #if INCLUDE_TCP_TEST DO_TEST(transport_tcp_test()); #endif #if INCLUDE_RESOLVE_TEST DO_TEST(resolve_test()); #endif #if INCLUDE_TSX_TEST status = pjsip_udp_transport_start(endpt, NULL, NULL, 1, &tp); if (status == PJ_SUCCESS) { tsx_test[tsx_test_cnt].port = tp->local_name.port; tsx_test[tsx_test_cnt].tp_type = "udp"; tsx_test[tsx_test_cnt].type = PJSIP_TRANSPORT_UDP; ++tsx_test_cnt; } #if PJ_HAS_TCP status = pjsip_tcp_transport_start(endpt, NULL, 1, &tpfactory); if (status == PJ_SUCCESS) { tsx_test[tsx_test_cnt].port = tpfactory->addr_name.port; tsx_test[tsx_test_cnt].tp_type = "tcp"; tsx_test[tsx_test_cnt].type = PJSIP_TRANSPORT_TCP; ++tsx_test_cnt; } else { app_perror("Unable to create TCP", status); rc = -4; goto on_return; } #endif for (i=0; i<tsx_test_cnt; ++i) { DO_TSX_TEST(tsx_basic_test, &tsx_test[i]); DO_TSX_TEST(tsx_uac_test, &tsx_test[i]); DO_TSX_TEST(tsx_uas_test, &tsx_test[i]); } #endif #if INCLUDE_INV_OA_TEST DO_TEST(inv_offer_answer_test()); #endif #if INCLUDE_REGC_TEST DO_TEST(regc_test()); #endif on_return: flush_events(500); /* Dumping memory pool usage */ PJ_LOG(3,(THIS_FILE, "Peak memory size=%u MB", caching_pool.peak_used_size / 1000000)); pjsip_endpt_destroy(endpt); pj_caching_pool_destroy(&caching_pool); PJ_LOG(3,(THIS_FILE, "")); pj_thread_get_stack_info(pj_thread_this(), &filename, &line); PJ_LOG(3,(THIS_FILE, "Stack max usage: %u, deepest: %s:%u", pj_thread_get_stack_max_usage(pj_thread_this()), filename, line)); if (rc == 0) PJ_LOG(3,(THIS_FILE, "Looks like everything is okay!..")); else PJ_LOG(3,(THIS_FILE, "Test completed with error(s)")); report_ival("test-status", rc, "", "Overall test status/result (0==success)"); close_report(); return rc; }
/** * Generate a test matrix for tabu search over TEA1, varying Tabu Search parameters * \param arcg number of input arguments * \param argv input argument string */ int main(int argc,char** argv){ input_options *options; full_test_input_options *test_options; cipher_cont *cipher=NULL; output_report *report; int lock=TRUE; unsigned long long tabu_list_length=0; unsigned long long tabu_iterations=0; unsigned long long tabu_max_decrease=0; unsigned long long change_move_limit=0; float key_eval_percent=0; if((test_options=MALLOC(full_test_input_options))==NULL){ fprintf(stderr,"ERROR: FAILED TO ALLOCATE MEMORY\n"); exit(1); } /* * parse input parameters */ if(argc>1){ parse_full_test_arguments(argc,argv,test_options); if(test_options->have_input==FALSE){ fprintf(stderr,"ERROR: NO INPUT FILE"); return(1); } } else{ print_full_test_options(argv[0]); return(1); } if(test_options->max_tabu_list_length==0){ test_options->max_tabu_list_length=TS_LIS_MAX; } if(test_options->max_tabu_iterations==0){ test_options->max_tabu_iterations=TS_ITER_MAX; } if(test_options->max_tabu_max_decrease==0){ test_options->max_tabu_max_decrease=TS_MAX_DEC_MAX; } if(test_options->max_change_move_limit==0){ test_options->max_change_move_limit=TS_CHM_MAX; } if(test_options->init_tabu_list_length==0){ test_options->init_tabu_list_length=TS_INIT_LIST; } if(test_options->init_tabu_iterations==0){ test_options->init_tabu_iterations=TS_INIT_ITER; } if(test_options->init_tabu_max_decrease==0){ test_options->init_tabu_max_decrease=TS_INIT_MAX_DEC; } if(test_options->init_change_move_limit==0){ test_options->init_change_move_limit=TS_INIT_CHM; } if(test_options->var_tabu_list_length==0){ test_options->var_tabu_list_length=TS_LIST_INCREMENT; } if(test_options->var_tabu_iterations==0){ test_options->var_tabu_iterations=TS_ITER_INCREMENT; } if(test_options->var_tabu_max_decrease==0){ test_options->var_tabu_max_decrease=TS_MAX_DEC_INCREMENT; } if(test_options->var_change_move_limit==0){ test_options->var_change_move_limit=TS_CHM_INCREMENT; } if(test_options->min_key_eval_percent==0){ test_options->min_key_eval_percent=(float)(TS_INIT_PERCENT); test_options->min_key_eval_percent=test_options->min_key_eval_percent/100; } if(test_options->var_key_eval_percent==0){ test_options->var_key_eval_percent=(float)(TS_PERCENT_INCREMENT); test_options->var_key_eval_percent=test_options->var_key_eval_percent/100; } options=convert_full_test_opt_to_gen(test_options); /* create report*/ report=open_report(options); report_use_test_matrix(report); /* read input from file */ cipher=read_input(test_options->inputfile); /* tabu serach parameters asignation */ tabu_iterations=test_options->min_key_eval_percent; tabu_list_length=test_options->init_tabu_list_length; tabu_max_decrease=test_options->init_tabu_max_decrease; key_eval_percent=test_options->min_key_eval_percent; change_move_limit=test_options->init_change_move_limit; printf("init test matrix\n"); print_mold_test_matrix(stdout); if(options->save_output) print_mold_test_matrix(report->report_file); /* iterative test matrix */ while(lock){ /* tabu search parameters refactory*/ options->tabu_list_length=tabu_list_length; /* tabu list lenght (DEFAULT 0) */ options->tabu_iterations=tabu_iterations; /* tabu iterations (DEFAULT 0) */ options->tabu_max_decrease=tabu_max_decrease; /* tabu performance max decrease (DEFAULT 0) */ options->key_eval_percent=key_eval_percent; /* percer for evaluation key */ options->change_move_limit=change_move_limit; /* perform tabu search */ tabusearch(cipher,options,report); /* use iteration test */ if(tabu_iterations<=test_options->max_tabu_iterations+1){ /* use list lenght test */ if(tabu_list_length<=test_options->max_tabu_list_length){ /* use key percent test */ if(key_eval_percent<=1){ /* use performance decreace test */ if(tabu_max_decrease<test_options->max_tabu_max_decrease){ /* use change movement limit test */ if(change_move_limit<test_options->max_change_move_limit){ change_move_limit+=test_options->var_change_move_limit; } else{ change_move_limit=test_options->init_change_move_limit; tabu_max_decrease+=test_options->var_tabu_max_decrease; } } else{ tabu_max_decrease=test_options->init_tabu_max_decrease; change_move_limit=test_options->init_change_move_limit; key_eval_percent+=test_options->var_key_eval_percent; } }else{ tabu_list_length+=test_options->var_tabu_list_length; key_eval_percent=test_options->min_key_eval_percent; tabu_max_decrease=test_options->init_tabu_max_decrease; change_move_limit=test_options->init_change_move_limit; } } else{ tabu_iterations+=test_options->var_tabu_iterations; tabu_list_length=test_options->init_tabu_list_length; tabu_max_decrease=test_options->init_tabu_max_decrease; key_eval_percent=test_options->min_key_eval_percent; change_move_limit=test_options->init_change_move_limit; } } else{ lock=FALSE; } } printf("end test matrix\n"); /* end program */ close_report(report); free((char *)options); free((char *)test_options); free((char *)report); free((char *)cipher); return(0); }