void test_Reverse_given_PAOBAAOOOH_find_AOOF_should_return_minus1(void) { TEST_ASSERT_EQUAL(-1,Reverse("PAOBAAOOH", "AOOF")); }
void test_channel_tcp(void) { int sock4, sock6; socklen_t size; struct sockaddr_in sin; struct addrunion addr4, addr6; struct channel_list *chan_list ; struct channel *chan4, *chan6, *chan = NULL; lagopus_result_t ret; int cnt; printf("test_channel_tcp in\n"); channel_mgr_initialize(); ret = channel_mgr_channels_lookup_by_dpid(dpid, &chan_list ); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); TEST_ASSERT_EQUAL(NULL, chan_list ); addrunion_ipv4_set(&addr4, "127.0.0.1"); addrunion_ipv6_set(&addr6, "::1"); ret = channel_mgr_channel_add(bridge_name, dpid, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_add(bridge_name, dpid, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_add(bridge_name, dpid, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ALREADY_EXISTS, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr4, &chan4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_EQUAL(0, channel_id_get(chan4)); ret = channel_port_set(chan4, 10022); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_port_set(chan4, 20022); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_addr_set(chan4, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_add(bridge_name, dpid, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ALREADY_EXISTS, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr6, &chan6); TEST_ASSERT_EQUAL(1, channel_id_get(chan6)); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_port_set(chan6, 10023); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_port_set(chan6, 20023); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_addr_set(chan6, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_lookup_by_channel_id(dpid, 1, &chan); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_NOT_EQUAL(NULL, chan); ret = channel_mgr_channel_lookup_by_channel_id(dpid, 9999, &chan); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); TEST_ASSERT_EQUAL(NULL, chan); cnt = 0; ret = channel_mgr_channels_lookup_by_dpid(dpid, &chan_list ); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_list_iterate(chan_list , channel_count, &cnt); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_EQUAL(2, cnt); cnt = 0; ret = channel_mgr_dpid_iterate(dpid, channel_count, &cnt); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_EQUAL(2, cnt); run = true; size = sizeof(sin); printf("accept in\n"); sock4 = accept(s4, (struct sockaddr *)&sin, &size); TEST_ASSERT_NOT_EQUAL(-1, sock4); sock6 = accept(s6, (struct sockaddr *)&sin, &size); TEST_ASSERT_NOT_EQUAL(-1, sock6); ret = channel_mgr_channel_lookup(bridge_name, &addr4, &chan4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); channel_refs_get(chan4); ret = channel_mgr_channel_delete(bridge_name, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); channel_refs_put(chan4); ret = channel_mgr_channel_delete(bridge_name, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr4, &chan4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); ret = channel_mgr_channel_delete(bridge_name, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr6, &chan6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); TEST_ASSERT_FALSE(channel_mgr_has_alive_channel_by_dpid(dpid)); ret = channel_mgr_event_upcall(); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); close(sock4); close(sock6); }
void setUp(void) { CMock_Guts_MemFreeAll(); StartingSize = CMock_Guts_MemBytesFree(); TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); }
TEST(vector_operations, vect_val_from_ind_returns_y_value_on_ind_2){ vect->v[1] = 77; TEST_ASSERT_EQUAL(77, Vect_read(vect, 2)); }
void test_service() { byte default_pins = _BV(BACK_PIN_CHANGE) | _BV(FRONT_PIN_CHANGE); // Initial state: hall sensors not triggered invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins); TEST_ASSERT_EQUAL(NotCalibrated, tank_joint.calibration); // Initiate calibration assert_correct_status(tank_arm_calibrate(test_device, TANK_JOINT)); TEST_ASSERT_EQUAL(Calibrating, tank_joint.calibration); // Some fake movement motor_step_tick(); motor_step_tick(); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_B_PIN_CHANGE)); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_A_PIN_CHANGE) | _BV(ENC_B_PIN_CHANGE)); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_A_PIN_CHANGE)); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_B_PIN_CHANGE)); TEST_ASSERT_EQUAL(-2, stepMotorPosition(tank_joint.motor)); TEST_ASSERT_EQUAL(-5, encoderState(tank_joint.encoder)); // Trigger back hall sensor. // Hall sensors are inverted, so only the front sensor pin is up. invokePinChangeInterrupt(PORT_PIN_CHANGE, _BV(FRONT_PIN_CHANGE)); motor_step_tick(); TEST_ASSERT_EQUAL(Calibrated, tank_joint.calibration); TEST_ASSERT_EQUAL(0, stepMotorPosition(tank_joint.motor)); TEST_ASSERT_EQUAL(0, encoderState(tank_joint.encoder)); // Initiate movement assert_correct_status(tank_arm_move(test_device, (TankArmLongParameter) { TANK_JOINT, 100 })); // 4 motor ticks, 5 encoder ticks (forward) motor_step_tick(); motor_step_tick(); motor_step_tick(); motor_step_tick(); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_A_PIN_CHANGE)); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_A_PIN_CHANGE) | _BV(ENC_B_PIN_CHANGE)); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_B_PIN_CHANGE)); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_A_PIN_CHANGE)); TEST_ASSERT_EQUAL(4, stepMotorPosition(tank_joint.motor)); TEST_ASSERT_EQUAL(5, encoderState(tank_joint.encoder)); // Trigger front hall sensor (force stop movement). invokePinChangeInterrupt(PORT_PIN_CHANGE, _BV(BACK_PIN_CHANGE)); motor_step_tick(); motor_step_tick(); motor_step_tick(); TEST_ASSERT_EQUAL(4, stepMotorPosition(tank_joint.motor)); // Note moving anymore // Move backwards a bit, since we are already at the front hall-sensor assert_correct_status(tank_arm_move(test_device, (TankArmLongParameter) { TANK_JOINT, -50 })); motor_step_tick(); motor_step_tick(); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins); invokePinChangeInterrupt(PORT_PIN_CHANGE, default_pins | _BV(ENC_B_PIN_CHANGE)); TankArmState state = {0}; assert_correct_status(tank_arm_state(test_device, TANK_JOINT, &state)); TEST_ASSERT_EQUAL(2, state.motorPos); TEST_ASSERT_EQUAL(3, state.encoderPos); TEST_ASSERT_EQUAL(Calibrated, state.calibration); TEST_ASSERT_EQUAL(FALSE, state.frontSensor); TEST_ASSERT_EQUAL(FALSE, state.backSensor); TEST_ASSERT_EQUAL(-50, state.targetPos); // Recalibrate assert_correct_status(tank_arm_calibrate(test_device, TANK_JOINT)); TEST_ASSERT_EQUAL(Calibrating, tank_joint.calibration); // Interrupt calibration by movement assert_correct_status(tank_arm_move(test_device, (TankArmLongParameter) { TANK_JOINT, 10 })); TEST_ASSERT_EQUAL(NotCalibrated, tank_joint.calibration); }
int32_t psa_aead_decrypt_test(security_t caller) { int32_t i, status; uint8_t plaintext[BUFFER_SIZE]; psa_key_policy_t policy; size_t plaintext_length; int num_checks = sizeof(check1)/sizeof(check1[0]); uint8_t *nonce, *additional_data; /* Initialize the PSA crypto library*/ status = val->crypto_function(VAL_CRYPTO_INIT); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(1)); for (i = 0; i < num_checks; i++) { val->print(PRINT_TEST, "[Check %d] ", g_test_count++); val->print(PRINT_TEST, check1[i].test_desc, 0); /* Initialize a key policy structure to a default that forbids all * usage of the key */ val->crypto_function(VAL_CRYPTO_KEY_POLICY_INIT, &policy); /* Setting up the watchdog timer for each check */ status = val->wd_reprogram_timer(WD_CRYPTO_TIMEOUT); TEST_ASSERT_EQUAL(status, VAL_STATUS_SUCCESS, TEST_CHECKPOINT_NUM(2)); /* Set the standard fields of a policy structure */ val->crypto_function(VAL_CRYPTO_KEY_POLICY_SET_USAGE, &policy, check1[i].usage, check1[i].key_alg); memset(plaintext, 0, sizeof(plaintext)); /* Allocate a key slot for a transient key */ status = val->crypto_function(VAL_CRYPTO_ALLOCATE_KEY, &check1[i].key_handle); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(3)); /* Set the usage policy on a key slot */ status = val->crypto_function(VAL_CRYPTO_SET_KEY_POLICY, check1[i].key_handle, &policy); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(4)); /* Import the key data into the key slot */ status = val->crypto_function(VAL_CRYPTO_IMPORT_KEY, check1[i].key_handle, check1[i].key_type, check1[i].key_data, check1[i].key_length); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(5)); if (is_buffer_empty(check1[i].nonce, check1[i].nonce_length) == TRUE) { nonce = NULL; check1[i].nonce_length = 0; } else nonce = check1[i].nonce; if (is_buffer_empty(check1[i].additional_data, check1[i].additional_data_length) == TRUE) { additional_data = NULL; check1[i].additional_data_length = 0; } else additional_data = check1[i].additional_data; /* Process an authenticated decryption operation */ status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, check1[i].key_handle, check1[i].key_alg, nonce, check1[i].nonce_length, additional_data, check1[i].additional_data_length, check1[i].ciphertext, check1[i].ciphertext_size, plaintext, check1[i].plaintext_size, &plaintext_length); TEST_ASSERT_EQUAL(status, check1[i].expected_status, TEST_CHECKPOINT_NUM(6)); if (check1[i].expected_status != PSA_SUCCESS) continue; /* Check if the length matches */ TEST_ASSERT_EQUAL(plaintext_length, check1[i].expected_plaintext_length, TEST_CHECKPOINT_NUM(7)); /* Check if the data matches */ TEST_ASSERT_MEMCMP(plaintext, check1[i].expected_plaintext, plaintext_length, TEST_CHECKPOINT_NUM(8)); } return VAL_STATUS_SUCCESS; }
TEST(vector_operations, kron_delta_should_return_one_when_indizes_are_equal){ TEST_ASSERT_EQUAL(1, kron_delta(10,10)); }
void test_findReverseText_given_WORLD_find_RL_should_return_2() { TEST_ASSERT_EQUAL(2, findReverseText("WORLD", "RL")); }
void test_findReverseText_given_PROGRAMMING_find_CD_should_return_minus_2() { TEST_ASSERT_EQUAL(-2, findReverseText("PROGRAMMING", "CD")); }
TEST(LightScheduler, CreateDoesNotChangeTheLights) { TEST_ASSERT_EQUAL(NONE, LightControllerSpy_GetLastId()); TEST_ASSERT_EQUAL(NONE, LightControllerSpy_GetLastState()); }
void test_findReverseText_given_HELLO_find_D_should_return_minus_2() { TEST_ASSERT_EQUAL(-2, findReverseText("HELLO", "D")); }
static void checkLightState(int id, int level) { TEST_ASSERT_EQUAL(id, LightControllerSpy_GetLastId()); TEST_ASSERT_EQUAL(level, LightControllerSpy_GetLastState()); }
TEST(LightScheduler, NoChangeToLightsDuringInitialization) { TEST_ASSERT_EQUAL(LIGHT_ID_UNKNOWN, LightControllerSpy_GetLastId()); TEST_ASSERT_EQUAL(LIGHT_STATE_UNKNOWN, LightControllerSpy_GetLastState()); }
void test_Reverse_given_LOVE_find_O_should_return_1(void) { TEST_ASSERT_EQUAL(1,Reverse("LOVE", "O")); }
static void gender_test(enum pkmn_game game) { enum pkmn_error error = PKMN_ERROR_NONE; enum pkmn_gender gender = PKMN_GENDER_GENDERLESS; // Single-gender struct pkmn_pokemon nidorina = empty_pokemon; error = pkmn_pokemon_init( PKMN_SPECIES_NIDORINA, game, "", 50, &nidorina ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NOT_NULL(nidorina.p_internal); error = pkmn_pokemon_get_gender( &nidorina, &gender ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_EQUAL(PKMN_GENDER_FEMALE, gender); error = pkmn_pokemon_set_gender( &nidorina, PKMN_GENDER_FEMALE ); PKMN_TEST_ASSERT_SUCCESS(error); error = pkmn_pokemon_set_gender( &nidorina, PKMN_GENDER_MALE ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_set_gender( &nidorina, PKMN_GENDER_GENDERLESS ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_free(&nidorina); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NULL(nidorina.p_internal); struct pkmn_pokemon nidorino = empty_pokemon; error = pkmn_pokemon_init( PKMN_SPECIES_NIDORINO, game, "", 50, &nidorino ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NOT_NULL(nidorino.p_internal); error = pkmn_pokemon_get_gender( &nidorino, &gender ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_EQUAL(PKMN_GENDER_MALE, gender); error = pkmn_pokemon_set_gender( &nidorino, PKMN_GENDER_MALE ); PKMN_TEST_ASSERT_SUCCESS(error); error = pkmn_pokemon_set_gender( &nidorino, PKMN_GENDER_FEMALE ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_set_gender( &nidorino, PKMN_GENDER_GENDERLESS ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_free(&nidorino); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NULL(nidorino.p_internal); struct pkmn_pokemon magnemite = empty_pokemon; error = pkmn_pokemon_init( PKMN_SPECIES_MAGNEMITE, game, "", 50, &magnemite ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NOT_NULL(magnemite.p_internal); error = pkmn_pokemon_get_gender( &magnemite, &gender ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_EQUAL(PKMN_GENDER_GENDERLESS, gender); error = pkmn_pokemon_set_gender( &magnemite, PKMN_GENDER_GENDERLESS ); PKMN_TEST_ASSERT_SUCCESS(error); error = pkmn_pokemon_set_gender( &magnemite, PKMN_GENDER_MALE ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_set_gender( &magnemite, PKMN_GENDER_FEMALE ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_free(&magnemite); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NULL(magnemite.p_internal); static const enum pkmn_species mixed_pokemon[] = { PKMN_SPECIES_CHARMANDER, // 87.% male PKMN_SPECIES_GROWLITHE, // 75% male PKMN_SPECIES_PIDGEY, // 50% male PKMN_SPECIES_VULPIX, // 25% male PKMN_SPECIES_NONE }; for(size_t pokemon_index = 0; mixed_pokemon[pokemon_index] != PKMN_SPECIES_NONE; ++pokemon_index) { struct pkmn_pokemon pokemon = empty_pokemon; error = pkmn_pokemon_init( mixed_pokemon[pokemon_index], game, "", 50, &pokemon ); PKMN_TEST_ASSERT_SUCCESS(error); error = pkmn_pokemon_get_gender( &pokemon, &gender ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NOT_EQUAL(PKMN_GENDER_GENDERLESS, gender); error = pkmn_pokemon_set_gender( &pokemon, PKMN_GENDER_MALE ); PKMN_TEST_ASSERT_SUCCESS(error); error = pkmn_pokemon_get_gender( &pokemon, &gender ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_EQUAL(PKMN_GENDER_MALE, gender); error = pkmn_pokemon_set_gender( &pokemon, PKMN_GENDER_FEMALE ); PKMN_TEST_ASSERT_SUCCESS(error); error = pkmn_pokemon_get_gender( &pokemon, &gender ); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_EQUAL(PKMN_GENDER_FEMALE, gender); error = pkmn_pokemon_set_gender( &pokemon, PKMN_GENDER_GENDERLESS ); TEST_ASSERT_EQUAL(PKMN_ERROR_INVALID_ARGUMENT, error); error = pkmn_pokemon_free(&pokemon); PKMN_TEST_ASSERT_SUCCESS(error); TEST_ASSERT_NULL(pokemon.p_internal); } }
void test_findReverseText_given_ABCDEFG_find_EF_should_return_4() { TEST_ASSERT_EQUAL(4, findReverseText("ABCDEFG", "EF")); }
int32_t psa_aead_decrypt_negative_test(security_t caller) { int32_t i, status; uint8_t plaintext[BUFFER_SIZE]; psa_key_policy_t policy; size_t plaintext_length; int num_checks = sizeof(check2)/sizeof(check2[0]); uint8_t *nonce, *additional_data; /* Initialize the PSA crypto library*/ status = val->crypto_function(VAL_CRYPTO_INIT); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(1)); for (i = 0; i < num_checks; i++) { /* Initialize a key policy structure to a default that forbids all * usage of the key */ val->crypto_function(VAL_CRYPTO_KEY_POLICY_INIT, &policy); /* Setting up the watchdog timer for each check */ status = val->wd_reprogram_timer(WD_CRYPTO_TIMEOUT); TEST_ASSERT_EQUAL(status, VAL_STATUS_SUCCESS, TEST_CHECKPOINT_NUM(2)); /* Set the standard fields of a policy structure */ val->crypto_function(VAL_CRYPTO_KEY_POLICY_SET_USAGE, &policy, check2[i].usage, check2[i].key_alg); if (is_buffer_empty(check2[i].nonce, check2[i].nonce_length) == TRUE) { nonce = NULL; check2[i].nonce_length = 0; } else nonce = check2[i].nonce; if (is_buffer_empty(check2[i].additional_data, check2[i].additional_data_length) == TRUE) { additional_data = NULL; check2[i].additional_data_length = 0; } else additional_data = check2[i].additional_data; val->print(PRINT_TEST, "[Check %d] Test psa_aead_decrypt - invalid key handle\n", g_test_count++); /* Process an authenticated decryption operation */ status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, check2[i].key_handle, check2[i].key_alg, nonce, check2[i].nonce_length, additional_data, check2[i].additional_data_length, check2[i].ciphertext, check2[i].ciphertext_size, plaintext, check2[i].plaintext_size, &plaintext_length); TEST_ASSERT_EQUAL(status, PSA_ERROR_INVALID_HANDLE, TEST_CHECKPOINT_NUM(3)); val->print(PRINT_TEST, "[Check %d] Test psa_aead_decrypt - zero as key handle\n", g_test_count++); /* Process an authenticated decryption operation */ status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, 0, check2[i].key_alg, nonce, check2[i].nonce_length, additional_data, check2[i].additional_data_length, check2[i].ciphertext, check2[i].ciphertext_size, plaintext, check2[i].plaintext_size, &plaintext_length); TEST_ASSERT_EQUAL(status, PSA_ERROR_INVALID_HANDLE, TEST_CHECKPOINT_NUM(4)); val->print(PRINT_TEST, "[Check %d] Test psa_aead_decrypt - empty key handle\n", g_test_count++); /* Allocate a key slot for a transient key */ status = val->crypto_function(VAL_CRYPTO_ALLOCATE_KEY, &check2[i].key_handle); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(5)); /* Set the usage policy on a key slot */ status = val->crypto_function(VAL_CRYPTO_SET_KEY_POLICY, check2[i].key_handle, &policy); TEST_ASSERT_EQUAL(status, PSA_SUCCESS, TEST_CHECKPOINT_NUM(6)); /* Process an authenticated decryption operation */ status = val->crypto_function(VAL_CRYPTO_AEAD_DECRYPT, check2[i].key_handle, check2[i].key_alg, nonce, check2[i].nonce_length, additional_data, check2[i].additional_data_length, check2[i].ciphertext, check2[i].ciphertext_size, plaintext, check2[i].plaintext_size, &plaintext_length); TEST_ASSERT_EQUAL(status, PSA_ERROR_EMPTY_SLOT, TEST_CHECKPOINT_NUM(7)); } return VAL_STATUS_SUCCESS; }
void test_findReverseText_given_DI_find_empty_string_should_return_minus_2() { TEST_ASSERT_EQUAL(-2, findReverseText("DI", "")); }
TEST(vector_operations, kron_delta_should_return_zero_when_indizes_are_not_equal){ TEST_ASSERT_EQUAL(0, kron_delta(1,0)); }
void test_findReverseText_given_ALADIN_find_A_should_return_2(void) { TEST_ASSERT_EQUAL(2,findReverseText("ALADIN", "A")); }
TEST(vector_operations, vect_val_from_ind_returns_x_value_on_ind_1){ vect->v[0] = 55; TEST_ASSERT_EQUAL(55, Vect_read(vect, 1)); }
bool test_osc_StateMap() { osc::StateMap map; osc::State *s1; osc::State *s2; osc::State *s3; osc::State *a1; osc::State *a2; osc::State *tmp; osc::nack_code_t status; s1=new osc::State(osc::Buffer(reinterpret_cast<const osc::byte_t*>("a"),1)); s2=new osc::State(osc::Buffer(reinterpret_cast<const osc::byte_t*>("b"),1)); s3=new osc::State(osc::Buffer(reinterpret_cast<const osc::byte_t*>("b"),1)); // A1 and A2 have state IDs that match in the first 6 characters. a1 = new osc::State(osc::Buffer(stateA1,10), 256,0,20); a2 = new osc::State(osc::Buffer(stateA2,10), 266,0,20); // Verify that A1 and A2 have matching state IDs for the first 6 chars osc::Buffer a1id(a1->getId()); osc::Buffer a2id(a2->getId()); a1id.truncate(6); a2id.truncate(6); TEST_ASSERT_EQUAL_BUFFERS(a1id.data(),a2id.data(), 6); // Add state 1 -- verify proper return s1->retain(); tmp = map.insert(s1); s1->release(); TEST_ASSERT_EQUAL(tmp, s1); // Ensure that we can find state 1 with a full ID tmp = 0; tmp = map.find(s1->getId(), status); TEST_ASSERT_EQUAL(tmp, s1); // Ensure that we can find state 1 with a partial ID osc::Buffer id1(s1->getId()); id1.truncate(6); tmp = 0; tmp = map.find(id1, status); TEST_ASSERT_EQUAL(tmp, s1); // Ensure that we get a proper error code before we add state 2 tmp = 0; tmp = map.find(s2->getId(), status); TEST_ASSERT_EQUAL(tmp, 0); TEST_ASSERT_EQUAL(status, osc::STATE_NOT_FOUND); // Add state 2 -- verify proper return s2->retain(); tmp = map.insert(s2); s2->release(); TEST_ASSERT_EQUAL(tmp, s2); // Ensure that we can find state 2 with a full ID tmp = 0; tmp = map.find(s2->getId(), status); TEST_ASSERT_EQUAL(tmp, s2); // Add state 3 -- verify that we get state 2 in return s3->retain(); tmp = map.insert(s3); tmp->release(); TEST_ASSERT_EQUAL(tmp, s2); // Ensure that we can still find state 2 with a full ID tmp = 0; tmp = map.find(s2->getId(), status); TEST_ASSERT_EQUAL(tmp, s2); // Remove state 1 tmp = map.remove(s1->getId()); TEST_ASSERT_EQUAL(tmp, s1); // Ensure that we get a proper error code after we remove state 1 tmp = 0; tmp = map.find(s1->getId(), status); TEST_ASSERT_EQUAL(tmp, 0); TEST_ASSERT_EQUAL(status, osc::STATE_NOT_FOUND); // Insert states whose IDs collide in the first 6 bytes a1->retain(); tmp = map.insert(a1); a1->release(); TEST_ASSERT_EQUAL(tmp, a1); a2->retain(); tmp = map.insert(a2); a2->release(); TEST_ASSERT_EQUAL(tmp, a2); // Ensure that we get a proper error code for colliding state IDs tmp = 0; tmp = map.find(a1id, status); TEST_ASSERT_EQUAL(tmp, 0); TEST_ASSERT_EQUAL(status, osc::ID_NOT_UNIQUE); delete(s1); return true; }
TEST(vector_operations, vect_val_from_ind_returns_z_value_on_ind_3){ vect->v[2] = 99; TEST_ASSERT_EQUAL(99, Vect_read(vect, 3)); }
static void given(int charsWritten) { TEST_ASSERT_EQUAL(strlen(expected), charsWritten); TEST_ASSERT_EQUAL_STRING(expected, output); TEST_ASSERT_BYTES_EQUAL(0xaa, output[strlen(expected)+1]); }
void if_with_else(void) { char * code = "int main()\ {\ if (1 == 1)\ {\ return 2;\ }\ else\ {\ return 4;\ }\ return 3;\ }"; lexer l; token_base * token; // Initialize lexer init_lexer(&l, code); /* * Check that the tokens generated are the right ones */ token = next(&l); // int TEST_ASSERT_EQUAL(T_INT_TYPE, token->type); token = next(&l); // main TEST_ASSERT_EQUAL(T_FUNCTION, token->type); token = next(&l); // ( TEST_ASSERT_EQUAL(T_OPAR, token->type); token = next(&l); // ) TEST_ASSERT_EQUAL(T_CPAR, token->type); token = next(&l); // { TEST_ASSERT_EQUAL(T_OBRA, token->type); token = next(&l); // if TEST_ASSERT_EQUAL(T_IF, token->type); token = next(&l); // ( TEST_ASSERT_EQUAL(T_OPAR, token->type); token = next(&l); // 1 TEST_ASSERT_EQUAL(T_INT_VALUE, token->type); token = next(&l); // == TEST_ASSERT_EQUAL(T_BOOLEAN_OP, token->type); token = next(&l); // 1 TEST_ASSERT_EQUAL(T_INT_VALUE, token->type); token = next(&l); // ) TEST_ASSERT_EQUAL(T_CPAR, token->type); token = next(&l); // { TEST_ASSERT_EQUAL(T_OBRA, token->type); token = next(&l); // return TEST_ASSERT_EQUAL(T_RETURN, token->type); token = next(&l); // 2 TEST_ASSERT_EQUAL(T_INT_VALUE, token->type); token = next(&l); // ; TEST_ASSERT_EQUAL(T_SEMICOLON, token->type); token = next(&l); // } TEST_ASSERT_EQUAL(T_CBRA, token->type); token = next(&l); // else TEST_ASSERT_EQUAL(T_ELSE, token->type); token = next(&l); // { TEST_ASSERT_EQUAL(T_OBRA, token->type); token = next(&l); // return TEST_ASSERT_EQUAL(T_RETURN, token->type); token = next(&l); // 4 TEST_ASSERT_EQUAL(T_INT_VALUE, token->type); token = next(&l); // ; TEST_ASSERT_EQUAL(T_SEMICOLON, token->type); token = next(&l); // } TEST_ASSERT_EQUAL(T_CBRA, token->type); token = next(&l); // return TEST_ASSERT_EQUAL(T_RETURN, token->type); token = next(&l); // 3 TEST_ASSERT_EQUAL(T_INT_VALUE, token->type); token = next(&l); // ; TEST_ASSERT_EQUAL(T_SEMICOLON, token->type); token = next(&l); // } TEST_ASSERT_EQUAL(T_CBRA, token->type); token = next(&l); // END_OF_FILE TEST_ASSERT_EQUAL(T_END_OF_FILE, token->type); // Destroy lexer destroy_lexer(&l); }
TEST(sprintf, NoFormatOperations2) { char output[5] = ""; TEST_ASSERT_EQUAL(3, sprintf(output, "hey")); TEST_ASSERT_EQUAL_STRING("hey", output); }
void setUp(void) { struct sockaddr_storage so = {0,0,{0}}; struct sockaddr_in *sin = (struct sockaddr_in *)&so; struct sockaddr_in6 *sin6; if (s4 != -1) { return; } sin->sin_family = AF_INET; sin->sin_port = htons(10022); sin->sin_addr.s_addr = INADDR_ANY; s4 = socket(AF_INET, SOCK_STREAM, 0); if (s4 < 0) { perror("socket"); exit(1); } if (bind(s4, (struct sockaddr *) sin, sizeof(*sin)) < 0) { perror("bind"); exit(1); } if (listen(s4, 5) < 0) { perror("listen"); exit(1); } sin6 = (struct sockaddr_in6 *)&so; sin6->sin6_family = AF_INET6; sin6->sin6_port = htons(10023); sin6->sin6_addr = in6addr_any; s6 = socket(AF_INET6, SOCK_STREAM, 0); if (s6 < 0) { perror("socket"); exit(1); } if (bind(s6, (struct sockaddr *) sin6, sizeof(*sin6)) < 0) { perror("bind"); exit(1); } if (listen(s6, 5) < 0) { perror("listen"); exit(1); } /* init datapath. */ TEST_ASSERT_EQUAL(dp_api_init(), LAGOPUS_RESULT_OK); /* interface. */ interface_info.type = DATASTORE_INTERFACE_TYPE_ETHERNET_RAWSOCK; interface_info.eth_rawsock.port_number = 0; interface_info.eth_dpdk_phy.device = strdup("eth0"); if (interface_info.eth_dpdk_phy.device == NULL) { TEST_FAIL_MESSAGE("device is NULL."); } TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_interface_create(interface_name)); dp_interface_info_set(interface_name, &interface_info); /* port. */ TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_port_create(port_name)); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_port_interface_set(port_name, interface_name)); /* bridge. */ bridge_info.dpid = dpid; bridge_info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE; bridge_info.max_buffered_packets = UINT32_MAX; bridge_info.max_ports = UINT16_MAX; bridge_info.max_tables = UINT8_MAX; bridge_info.max_flows = UINT32_MAX; bridge_info.capabilities = UINT64_MAX; bridge_info.action_types = UINT64_MAX; bridge_info.instruction_types = UINT64_MAX; bridge_info.reserved_port_types = UINT64_MAX; bridge_info.group_types = UINT64_MAX; bridge_info.group_capabilities = UINT64_MAX; TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_bridge_create(bridge_name, &bridge_info)); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_bridge_port_set(bridge_name, port_name, 0)); printf("setup end\n"); }
TEST(sprintf, InsertString) { char output[20] = ""; TEST_ASSERT_EQUAL(12, sprintf(output, "Hello %s\n", "World")); TEST_ASSERT_EQUAL_STRING("Hello World\n", output); }
void test_ThatWeCanClaimAndChainAFewElementsTogether(void) { unsigned int i; CMOCK_MEM_INDEX_TYPE first = CMOCK_GUTS_NONE; CMOCK_MEM_INDEX_TYPE next; CMOCK_MEM_INDEX_TYPE element[4]; //verify we're cleared first TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree()); //first element element[0] = CMock_Guts_MemNew(sizeof(unsigned int)); TEST_ASSERT_MESSAGE(element[0] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE"); first = CMock_Guts_MemChain(first, element[0]); TEST_ASSERT_EQUAL(element[0], first); *((unsigned int*)CMock_Guts_GetAddressFor(element[0])) = 0; //verify we're using the right amount of memory TEST_ASSERT_EQUAL(1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize - 1 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree()); //second element element[1] = CMock_Guts_MemNew(sizeof(unsigned int)); TEST_ASSERT_MESSAGE(element[1] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE"); TEST_ASSERT_NOT_EQUAL(element[0], element[1]); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[1])); *((unsigned int*)CMock_Guts_GetAddressFor(element[1])) = 1; //verify we're using the right amount of memory TEST_ASSERT_EQUAL(2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize - 2 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree()); //third element element[2] = CMock_Guts_MemNew(sizeof(unsigned int)); TEST_ASSERT_MESSAGE(element[2] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE"); TEST_ASSERT_NOT_EQUAL(element[0], element[2]); TEST_ASSERT_NOT_EQUAL(element[1], element[2]); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[2])); *((unsigned int*)CMock_Guts_GetAddressFor(element[2])) = 2; //verify we're using the right amount of memory TEST_ASSERT_EQUAL(3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize - 3 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree()); //fourth element element[3] = CMock_Guts_MemNew(sizeof(unsigned int)); TEST_ASSERT_MESSAGE(element[3] != CMOCK_GUTS_NONE, "Should Not Have Returned CMOCK_GUTS_NONE"); TEST_ASSERT_NOT_EQUAL(element[0], element[3]); TEST_ASSERT_NOT_EQUAL(element[1], element[3]); TEST_ASSERT_NOT_EQUAL(element[2], element[3]); TEST_ASSERT_EQUAL(first, CMock_Guts_MemChain(first, element[3])); *((unsigned int*)CMock_Guts_GetAddressFor(element[3])) = 3; //verify we're using the right amount of memory TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize - 4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree()); //traverse list next = first; for (i = 0; i < 4; i++) { TEST_ASSERT_EQUAL(element[i], next); TEST_ASSERT_EQUAL(i, *((unsigned int*)CMock_Guts_GetAddressFor(element[i]))); next = CMock_Guts_MemNext(next); } //verify we get a null at the end of the list TEST_ASSERT_EQUAL_HEX( CMOCK_GUTS_NONE, next); //verify we're using the right amount of memory TEST_ASSERT_EQUAL(4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize - 4 * (TEST_MEM_INDEX_PAD + 8), CMock_Guts_MemBytesFree()); //Free it all CMock_Guts_MemFreeAll(); //verify we're cleared TEST_ASSERT_EQUAL(0, CMock_Guts_MemBytesUsed()); TEST_ASSERT_EQUAL(StartingSize, CMock_Guts_MemBytesFree()); }
void test_Reverse_given_PAOBAAOH_find_AOH_should_return_5(void) { TEST_ASSERT_EQUAL(5,Reverse("PAOBAAOH", "AOH")); }