TEST(dynmem, test_both_allocs_with_hole_usage) { uint16_t size = 112; mem_stat_t info; void *p[size]; uint8_t *heap = (uint8_t*)malloc(size); CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); void *ptr = ns_dyn_mem_alloc(15); void *ptr2 = ns_dyn_mem_alloc(4); ns_dyn_mem_free(ptr); ns_dyn_mem_free(ptr2); CHECK(info.heap_sector_allocated_bytes == 0); void *ptr3 = ns_dyn_mem_temporary_alloc(15); void *ptr4 = ns_dyn_mem_temporary_alloc(5); ns_dyn_mem_free(ptr3); ns_dyn_mem_free(ptr4); CHECK(info.heap_sector_allocated_bytes == 0); free(heap); }
uint8_t *sec_prot_lib_message_build(uint8_t *ptk, uint8_t *kde, uint16_t kde_len, eapol_pdu_t *eapol_pdu, uint16_t eapol_pdu_size, uint8_t header_size) { uint8_t *eapol_pdu_frame = ns_dyn_mem_temporary_alloc(header_size + eapol_pdu_size); if (!eapol_pdu_frame) { return NULL; } uint8_t *eapol_kde = eapol_write_pdu_frame(eapol_pdu_frame + header_size, eapol_pdu); if (kde) { if (eapol_pdu->msg.key.key_information.encrypted_key_data) { size_t output_len = kde_len; if (nist_aes_key_wrap(1, &ptk[KEK_INDEX], 128, kde, kde_len - 8, eapol_kde, &output_len) < 0 || output_len != kde_len) { ns_dyn_mem_free(eapol_pdu_frame); return NULL; } } else { memcpy(eapol_kde, kde, kde_len); } } if (eapol_pdu->msg.key.key_information.key_mic) { uint8_t mic[EAPOL_KEY_MIC_LEN]; if (hmac_sha1_calc(ptk, KCK_LEN, eapol_pdu_frame + header_size, eapol_pdu_size, mic) < 0) { ns_dyn_mem_free(eapol_pdu_frame); return NULL; } eapol_write_key_packet_mic(eapol_pdu_frame + header_size, mic); } return eapol_pdu_frame; }
/** * Free allocated load balance class */ static void load_balance_class_free(lb_internal_t *api) { //Clean heared networks ns_dyn_mem_free(api->notified_network); lb_border_router_api_free(api); ns_dyn_mem_free(api); }
TEST(dynmem, not_negative_stats) { uint16_t size = 1000; mem_stat_t info; uint8_t *heap = (uint8_t*)malloc(size); void *p; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); CHECK(info.heap_sector_allocated_bytes == 0); ns_dyn_mem_alloc(8); p = ns_dyn_mem_alloc(8); ns_dyn_mem_alloc(8); CHECK(info.heap_sector_allocated_bytes >= 24); int16_t last_value = info.heap_sector_allocated_bytes; ns_dyn_mem_free(p); CHECK(info.heap_sector_allocated_bytes >= 16); CHECK(info.heap_sector_allocated_bytes < last_value); last_value = info.heap_sector_allocated_bytes; for (int i=0; i<10; i++) { p = ns_dyn_mem_alloc(1); ns_dyn_mem_free(p); } CHECK(info.heap_sector_allocated_bytes == last_value); free(heap); }
nwk_pan_descriptor_t *mac_helper_free_pan_descriptions(nwk_pan_descriptor_t *nwk_cur_active) { if (nwk_cur_active) { ns_dyn_mem_free(nwk_cur_active->pan_descriptor); ns_dyn_mem_free(nwk_cur_active->beacon_payload); ns_dyn_mem_free(nwk_cur_active); } return NULL; }
TEST(dynmem, ns_dyn_mem_alloc) { uint16_t size = 1000; mem_stat_t info; void *p[size]; uint8_t *heap = (uint8_t*)malloc(size); CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); int block = 1; int i; for (i=0; i<size; i++) { p[i] = ns_dyn_mem_alloc(block); if (!p[i]) break; } CHECK(!heap_have_failed()); CHECK(info.heap_alloc_fail_cnt == 1); CHECK(info.heap_sector_alloc_cnt == i); CHECK(info.heap_sector_allocated_bytes == info.heap_sector_allocated_bytes_max); for (; i>=0; i--) { ns_dyn_mem_free(p[i]); } CHECK(!heap_have_failed()); CHECK(info.heap_sector_alloc_cnt == 0); free(heap); }
void coap_security_destroy(coap_security_t *sec){ if( sec ){ coap_security_handler_reset(sec); ns_dyn_mem_free(sec); sec = NULL; } }
coap_security_t *coap_security_create(int8_t socket_id, int8_t timer_id, uint8_t *address_ptr, uint16_t port, SecureConnectionMode mode, send_cb *send_cb, receive_cb *receive_cb, start_timer_cb *start_timer_cb, timer_status_cb *timer_status_cb) { if( !address_ptr || send_cb == NULL || receive_cb == NULL || start_timer_cb == NULL || timer_status_cb == NULL){ return NULL; } coap_security_t *this = ns_dyn_mem_alloc(sizeof(coap_security_t)); if( !this ){ return NULL; } memset(this, 0, sizeof(coap_security_t)); if( -1 == coap_security_handler_init(this) ){ ns_dyn_mem_free(this); return NULL; } this->_remote_port = port; memcpy(this->_remote_address, address_ptr, 16); this->_conn_mode = mode; memset(this->_pw, 0, 64); this->_pw_len = 0; this->_socket_id = socket_id; this->_timer_id = timer_id; this->_send_cb = send_cb; this->_receive_cb = receive_cb; this->_start_timer_cb = start_timer_cb; this->_timer_status_cb = timer_status_cb; return this; }
coap_security_t *coap_security_create(int8_t socket_id, int8_t timer_id, void *handle, SecureConnectionMode mode, send_cb *socket_cb, receive_cb *receive_data_cb, start_timer_cb *timer_start_cb, timer_status_cb *timer_stat_cb) { if (socket_cb == NULL || receive_data_cb == NULL || timer_start_cb == NULL || timer_stat_cb == NULL) { return NULL; } coap_security_t *this = ns_dyn_mem_alloc(sizeof(coap_security_t)); if( !this ){ return NULL; } memset(this, 0, sizeof(coap_security_t)); if (-1 == coap_security_handler_init(this)) { ns_dyn_mem_free(this); return NULL; } this->_handle = handle; this->_conn_mode = mode; memset(this->_pw, 0, 64); this->_pw_len = 0; this->_socket_id = socket_id; this->_timer_id = timer_id; this->_send_cb = socket_cb; this->_receive_cb = receive_data_cb; this->_start_timer_cb = timer_start_cb; this->_timer_status_cb = timer_stat_cb; return this; }
uint8_t *sec_prot_lib_message_handle(uint8_t *ptk, uint16_t *kde_len, eapol_pdu_t *eapol_pdu) { if (eapol_pdu->msg.key.key_data_length == 0 || eapol_pdu->msg.key.key_data == NULL) { return NULL; } uint8_t *key_data = eapol_pdu->msg.key.key_data; uint16_t key_data_len = eapol_pdu->msg.key.key_data_length; uint8_t *kde = ns_dyn_mem_temporary_alloc(key_data_len); *kde_len = key_data_len; if (eapol_pdu->msg.key.key_information.encrypted_key_data) { size_t output_len = eapol_pdu->msg.key.key_data_length; if (nist_aes_key_wrap(0, &ptk[KEK_INDEX], 128, key_data, key_data_len, kde, &output_len) < 0 || output_len != (size_t) key_data_len - 8) { ns_dyn_mem_free(kde); return NULL; } *kde_len = output_len; } else { memcpy(kde, key_data, *kde_len); } return kde; }
// XXX: a ns_dyn_mem_realloc() would be nice to have uint8_t *mac_helper_beacon_payload_reallocate(protocol_interface_info_entry_t *interface, uint8_t len) { if (len == interface->mac_parameters->mac_beacon_payload_size) { // no change to size, return the existing buff //Set allways length to zero for safe beacon payload manipulate mac_helper_beacon_payload_length_set_to_mac(interface, 0); return interface->mac_parameters->mac_beacon_payload; } if (len == 0) { //SET MAC beacon payload to length to zero mac_helper_beacon_payload_length_set_to_mac(interface, 0); ns_dyn_mem_free(interface->mac_parameters->mac_beacon_payload); interface->mac_parameters->mac_beacon_payload = NULL; interface->mac_parameters->mac_beacon_payload_size = 0; return NULL; } tr_debug("mac_helper_beacon_payload_reallocate, old len: %d, new: %d", interface->mac_parameters->mac_beacon_payload_size, len); uint8_t *temp_buff = ns_dyn_mem_alloc(len); if (temp_buff == NULL) { // no need to proceed, could not allocate more space return NULL; } //SET MAC beacon payload to length to zero mac_helper_beacon_payload_length_set_to_mac(interface, 0); // copy data into new buffer before freeing old one if (interface->mac_parameters->mac_beacon_payload_size > 0) { const uint8_t min_len = MIN(len, interface->mac_parameters->mac_beacon_payload_size); memcpy(temp_buff, interface->mac_parameters->mac_beacon_payload, min_len); ns_dyn_mem_free(interface->mac_parameters->mac_beacon_payload); } //Set New Length and pointer to MAC interface->mac_parameters->mac_beacon_payload = temp_buff; interface->mac_parameters->mac_beacon_payload_size = len; return interface->mac_parameters->mac_beacon_payload; }
/* * \brief Configure mesh network * */ void thread_tasklet_configure_and_connect_to_network(void) { int8_t status; link_configuration_s* temp_link_config=NULL; if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_MINIMAL_END_DEVICE) { thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_HOST; } else if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_SLEEPY_END_DEVICE) { thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_SLEEPY_HOST; } else { thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_ROUTER; } arm_nwk_interface_configure_6lowpan_bootstrap_set( thread_tasklet_data_ptr->nwk_if_id, thread_tasklet_data_ptr->operating_mode, NET_6LOWPAN_THREAD); thread_tasklet_data_ptr->channel_list.channel_page = (channel_page_e)MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_PAGE; thread_tasklet_data_ptr->channel_list.channel_mask[0] = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_MASK; TRACE_DETAIL("channel page: %d", thread_tasklet_data_ptr->channel_list.channel_page); TRACE_DETAIL("channel mask: 0x%.8lx", thread_tasklet_data_ptr->channel_list.channel_mask[0]); // PSKd const char PSKd[] = MBED_CONF_MBED_MESH_API_THREAD_PSKD; MBED_ASSERT(sizeof(PSKd) > 5 && sizeof(PSKd) < 33); char *dyn_buf = ns_dyn_mem_alloc(sizeof(PSKd)); strcpy(dyn_buf, PSKd); ns_dyn_mem_free(device_configuration.PSKd_ptr); device_configuration.PSKd_ptr = (uint8_t*)dyn_buf; device_configuration.PSKd_len = sizeof(PSKd) - 1; if (true == MBED_CONF_MBED_MESH_API_THREAD_USE_STATIC_LINK_CONFIG) { read_link_configuration(); temp_link_config = &thread_tasklet_data_ptr->link_config; } thread_management_node_init(thread_tasklet_data_ptr->nwk_if_id, &thread_tasklet_data_ptr->channel_list, &device_configuration, temp_link_config); status = arm_nwk_interface_up(thread_tasklet_data_ptr->nwk_if_id); if (status >= 0) { thread_tasklet_data_ptr->tasklet_state = TASKLET_STATE_BOOTSTRAP_STARTED; tr_info("Start Thread bootstrap (%s mode)", thread_tasklet_data_ptr->operating_mode == NET_6LOWPAN_SLEEPY_HOST ? "SED" : "Router"); } else { thread_tasklet_data_ptr->tasklet_state = TASKLET_STATE_BOOTSTRAP_FAILED; tr_err("Bootstrap start failed, %d", status); thread_tasklet_network_state_changed(MESH_BOOTSTRAP_START_FAILED); } }
/** * Load balance border router class free */ static int8_t lb_border_router_api_free(lb_internal_t *api) { if (api->lb_border_router) { ns_dyn_mem_free(api->lb_border_router); api->lb_border_router = NULL; return 0; } return -1; }
TEST(dynmem, double_free) { uint16_t size = 1000; mem_stat_t info; uint8_t *heap = (uint8_t*)malloc(size); void *p; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); p = ns_dyn_mem_alloc(100); CHECK(p); ns_dyn_mem_free(p); CHECK(!heap_have_failed()); ns_dyn_mem_free(p); CHECK(heap_have_failed()); CHECK(NS_DYN_MEM_DOUBLE_FREE == current_heap_error); free(heap); }
TEST(dynmem, test_free_corrupted_next_block) { uint16_t size = 1000; uint8_t *heap = (uint8_t*)malloc(size); uint8_t *p; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, NULL); CHECK(!heap_have_failed()); int *ptr = (int *)ns_dyn_mem_temporary_alloc(4); int *ptr2 = (int *)ns_dyn_mem_temporary_alloc(4); ns_dyn_mem_free(ptr); ptr = ptr2 + 2; *ptr = -2; ns_dyn_mem_free(ptr2); CHECK(NS_DYN_MEM_HEAP_SECTOR_CORRUPTED == current_heap_error); free(heap); }
int8_t net_nvm_wpan_params_storage_disable(int8_t interface_id) { protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id); if (!cur || !cur->nwk_wpan_nvm_api) { return -1; } ns_dyn_mem_free(cur->nwk_wpan_nvm_api); cur->nwk_wpan_nvm_api = NULL; return 0; }
TEST(dynmem, not_from_this_heap) { uint16_t size = 1000; mem_stat_t info; uint8_t *heap = (uint8_t*)malloc(size); uint8_t *p; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); p = (uint8_t *)ns_dyn_mem_alloc(100); CHECK(p); ns_dyn_mem_free(&heap[-1]); CHECK(heap_have_failed()); CHECK(NS_DYN_MEM_POINTER_NOT_VALID == current_heap_error); reset_heap_error(); ns_dyn_mem_free(&heap[1001]); CHECK(heap_have_failed()); CHECK(NS_DYN_MEM_POINTER_NOT_VALID == current_heap_error); free(heap); }
TEST(dynmem, middle_free) { uint16_t size = 1000; mem_stat_t info; uint8_t *heap = (uint8_t*)malloc(size); void *p[3]; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); for (int i=0; i<3; i++) { p[i] = ns_dyn_mem_temporary_alloc(100); CHECK(p); } ns_dyn_mem_free(p[1]); CHECK(!heap_have_failed()); ns_dyn_mem_free(p[0]); CHECK(!heap_have_failed()); ns_dyn_mem_free(p[2]); CHECK(!heap_have_failed()); free(heap); }
int ns_file_system_set_root_path(const char *root_path) { char *new_root_path; if (root_path == NULL) { // File system usage disabled ns_dyn_mem_free(file_system_root); file_system_root = NULL; return 0; } new_root_path = ns_dyn_mem_alloc(strlen(root_path) + 1); if (!new_root_path) { // mem alloc failed return -2; } ns_dyn_mem_free(file_system_root); file_system_root = new_root_path; strcpy(file_system_root, root_path); return 0; }
TEST(dynmem, test_invalid_pointer_freed) { uint16_t size = 92; uint8_t *heap = (uint8_t*)malloc(size); CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, NULL); int *ptr = (int *)ns_dyn_mem_alloc(4); ptr--; *ptr = 16; ptr++; ns_dyn_mem_free(ptr); CHECK(NS_DYN_MEM_POINTER_NOT_VALID == current_heap_error); free(heap); }
uint8_t thread_tasklet_device_pskd_set(const char *pskd) { int len = strlen(pskd); if(len < 6 || len > 32) { return MESH_ERROR_PARAM; } char *dyn_buf = ns_dyn_mem_alloc(strlen(pskd)+1); if (!dyn_buf) { return MESH_ERROR_MEMORY; } strcpy(dyn_buf, pskd); ns_dyn_mem_free(device_configuration.PSKd_ptr); device_configuration.PSKd_ptr = (uint8_t*)dyn_buf; device_configuration.PSKd_len = strlen(pskd); return 0; }
/** * Allocate notified network class */ static bool load_balance_network_class_allocate(lb_internal_t *lb_store_ptr, uint16_t beacon_max_payload_length) { ns_dyn_mem_free(lb_store_ptr->notified_network); lb_store_ptr->beacon_max_payload_length = 0; if (beacon_max_payload_length) { lb_store_ptr->notified_network = ns_dyn_mem_alloc(sizeof(lb_network_t) + beacon_max_payload_length); if (!lb_store_ptr->notified_network) { return false; } lb_store_ptr->notified_network->network_switch_accepted = false; lb_store_ptr->notified_network->priority = 0xff; lb_store_ptr->notified_network->state = LB_NWK_SWITCH_IDLE; lb_store_ptr->notified_network->state_timer = 0; lb_store_ptr->beacon_max_payload_length = beacon_max_payload_length; } return true; }
TEST(dynmem, over_by_one) { uint16_t size = 1000; mem_stat_t info; uint8_t *heap = (uint8_t*)malloc(size); uint8_t *p; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); p = (uint8_t *)ns_dyn_mem_alloc(100); CHECK(p); p[100] = 0xff; ns_dyn_mem_free(p); CHECK(heap_have_failed()); CHECK(NS_DYN_MEM_HEAP_SECTOR_CORRUPTED == current_heap_error); free(heap); }
int entropy_poll( void *ctx, unsigned char *output, size_t len, size_t *olen ) { (void)ctx; //TODO: change to more secure random randLIB_seed_random(); char *c = (char*)ns_dyn_mem_temporary_alloc(len); if( !c ){ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED; } memset(c, 0, len); for(uint16_t i=0; i < len; i++){ *(c + i) = (char)randLIB_get_8bit(); } memmove(output, c, len); *olen = len; ns_dyn_mem_free(c); return( 0 ); }
TEST(dynmem, diff_sizes) { uint16_t size = 1000; mem_stat_t info; void *p; uint8_t *heap = (uint8_t*)malloc(size); CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); int i; for (i=1; i<(size-72); i++) { p = ns_dyn_mem_temporary_alloc(i); CHECK(p); ns_dyn_mem_free(p); CHECK(!heap_have_failed()); } CHECK(!heap_have_failed()); CHECK(info.heap_sector_alloc_cnt == 0); free(heap); }
int8_t mac_helper_nwk_id_filter_set(const uint8_t *nw_id, nwk_filter_params_s *filter) { if (!filter) { return -1; } int8_t ret_val = 0; if (nw_id) { if (filter->beacon_nwk_id_filter == 0) { filter->beacon_nwk_id_filter = ns_dyn_mem_alloc(16); } if (filter->beacon_nwk_id_filter) { memcpy(filter->beacon_nwk_id_filter, nw_id, 16); } else { ret_val = -1; } } else { ns_dyn_mem_free(filter->beacon_nwk_id_filter); filter->beacon_nwk_id_filter = 0; } return ret_val; }
TEST(dynmem, no_big_enough_sector) { uint16_t size = 112; mem_stat_t info; uint8_t *heap = (uint8_t*)malloc(size); uint8_t *ptr = heap; CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); int *pt = (int *)ns_dyn_mem_alloc(8); pt = (int *)ns_dyn_mem_alloc(8); ns_dyn_mem_alloc(8); ns_dyn_mem_temporary_alloc(8); ns_dyn_mem_temporary_alloc(8); ns_dyn_mem_free(pt); pt = (int *)ns_dyn_mem_temporary_alloc(32); CHECK(NULL == pt); free(heap); }
int8_t ws_pae_controller_delete(protocol_interface_info_entry_t *interface_ptr) { if (!interface_ptr) { return -1; } ws_pae_controller_stop(interface_ptr); pae_controller_t *controller = ws_pae_controller_get(interface_ptr); if (!controller) { return -1; } ns_list_remove(&pae_controller_list, controller); sec_prot_certs_delete(&controller->certs); ns_dyn_mem_free(controller); return 0; }
TEST(dynmem, ns_dyn_mem_temporary_alloc_with_heap_threshold) { uint16_t size = 1000; mem_stat_t info; void *p1, *p2; int ret_val; uint8_t *heap = (uint8_t*)malloc(size); CHECK(NULL != heap); reset_heap_error(); ns_dyn_mem_init(heap, size, &heap_fail_callback, &info); CHECK(!heap_have_failed()); // test1: temporary alloc will fail if there is less than 5% heap free p1 = ns_dyn_mem_temporary_alloc((size-72)*0.96); CHECK(!heap_have_failed()); CHECK(p1); p2 = ns_dyn_mem_temporary_alloc((size-72)*0.02); CHECK(p2 == NULL); CHECK(!heap_have_failed()); CHECK(info.heap_alloc_fail_cnt == 1); // Test2, disable threshold feature and try p2 allocation again ns_dyn_mem_set_temporary_alloc_free_heap_threshold(0, 0); p2 = ns_dyn_mem_temporary_alloc((size-72)*0.02); CHECK(!heap_have_failed()); CHECK(p2); ns_dyn_mem_free(p1); ns_dyn_mem_free(p2); CHECK(info.heap_alloc_fail_cnt == 1); CHECK(info.heap_sector_alloc_cnt == 0); // Test3, enable feature by free heap percentage ns_dyn_mem_set_temporary_alloc_free_heap_threshold(40, 0); p1 = ns_dyn_mem_temporary_alloc((size-72)*0.65); CHECK(p1); p2 = ns_dyn_mem_temporary_alloc((size-72)*0.10); CHECK(p2==NULL); ns_dyn_mem_free(p1); CHECK(!heap_have_failed()); CHECK(info.heap_alloc_fail_cnt == 2); CHECK(info.heap_sector_alloc_cnt == 0); // Test4, enable feature by free heap amount ns_dyn_mem_set_temporary_alloc_free_heap_threshold(0, 200); p1 = ns_dyn_mem_temporary_alloc(size-72-100 /*828 bytes */); CHECK(p1); p2 = ns_dyn_mem_temporary_alloc(1); CHECK(p2==NULL); ns_dyn_mem_free(p1); // Test5, illegal API parameters ret_val = ns_dyn_mem_set_temporary_alloc_free_heap_threshold(0, size/2); CHECK(ret_val==-2); ret_val = ns_dyn_mem_set_temporary_alloc_free_heap_threshold(0, size*2); CHECK(ret_val==-2); ret_val = ns_dyn_mem_set_temporary_alloc_free_heap_threshold(51, 0); CHECK(ret_val==-2); ret_val = ns_dyn_mem_set_temporary_alloc_free_heap_threshold(255, 0); CHECK(ret_val==-2); CHECK(!heap_have_failed()); CHECK(info.heap_alloc_fail_cnt == 3); CHECK(info.heap_sector_alloc_cnt == 0); free(heap); // Test6, feature is disabled if info is not set heap = (uint8_t*)malloc(size); CHECK(NULL != heap); ns_dyn_mem_init(heap, size, &heap_fail_callback, NULL); ret_val = ns_dyn_mem_set_temporary_alloc_free_heap_threshold(0, 0); CHECK(ret_val==-1); CHECK(!heap_have_failed()); free(heap); }
//NOTE! This test must be last! TEST(dynmem, uninitialized_test){ void *p = ns_dyn_mem_alloc(4); ns_dyn_mem_free(p); CHECK(p == NULL); }