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"));
}
