bool test_aecp ( void )
{
bool r = false;
START_TEST();
END_TEST ( r );
return r;
}
static void
test_validate_fractional_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "a");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad integer");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "3..4");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad integer");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "3.4.5");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad integer");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional", "0");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, NULL),
"validation had a false positive");
END_TEST();
}
int main(int argc, char **argv)
{
struct s2n_connection *conn;
uint8_t mac_key[] = "sample mac key";
uint8_t aes128_key[] = "123456789012345";
struct s2n_blob aes128 = {.data = aes128_key,.size = sizeof(aes128_key) };
uint8_t random_data[S2N_LARGE_RECORD_LENGTH + 1];
struct s2n_blob r = {.data = random_data, .size = sizeof(random_data)};
BEGIN_TEST();
EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_SERVER));
EXPECT_SUCCESS(s2n_get_urandom_data(&r));
/* Peer and we are in sync */
conn->server = &conn->secure;
conn->client = &conn->secure;
/* test the AES128 cipher with a SHA1 hash */
conn->secure.cipher_suite->cipher = &s2n_aes128;
conn->secure.cipher_suite->hmac_alg = S2N_HMAC_SHA1;
EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->get_encryption_key(&conn->secure.server_key, &aes128));
EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->get_decryption_key(&conn->secure.client_key, &aes128));
EXPECT_SUCCESS(s2n_hmac_init(&conn->secure.client_record_mac, S2N_HMAC_SHA1, mac_key, sizeof(mac_key)));
EXPECT_SUCCESS(s2n_hmac_init(&conn->secure.server_record_mac, S2N_HMAC_SHA1, mac_key, sizeof(mac_key)));
conn->actual_protocol_version = S2N_TLS11;
/* Align the record size, then subtract 20 bytes for the HMAC, 16 bytes for the explicit IV, and one byte
* for the padding length byte.
*/
int small_aligned_payload = S2N_SMALL_FRAGMENT_LENGTH - (S2N_SMALL_FRAGMENT_LENGTH % 16) - 20 - 16 - 1;
int large_aligned_payload = S2N_LARGE_FRAGMENT_LENGTH - (S2N_LARGE_FRAGMENT_LENGTH % 16) - 20 - 16 - 1;
int bytes_written;
/* Check the default: small record */
EXPECT_SUCCESS(s2n_stuffer_wipe(&conn->out));
EXPECT_SUCCESS(bytes_written = s2n_record_write(conn, TLS_APPLICATION_DATA, &r));
EXPECT_EQUAL(bytes_written, small_aligned_payload);
/* Check explicitly small records */
EXPECT_SUCCESS(s2n_connection_prefer_low_latency(conn));
EXPECT_SUCCESS(s2n_stuffer_wipe(&conn->out));
EXPECT_SUCCESS(bytes_written = s2n_record_write(conn, TLS_APPLICATION_DATA, &r));
EXPECT_EQUAL(bytes_written, small_aligned_payload);
/* Check explicitly large records */
EXPECT_SUCCESS(s2n_connection_prefer_throughput(conn));
EXPECT_SUCCESS(s2n_stuffer_wipe(&conn->out));
EXPECT_SUCCESS(bytes_written = s2n_record_write(conn, TLS_APPLICATION_DATA, &r));
EXPECT_EQUAL(bytes_written, large_aligned_payload);
/* Clean up */
EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->destroy_key(&conn->secure.server_key));
EXPECT_SUCCESS(conn->secure.cipher_suite->cipher->destroy_key(&conn->secure.client_key));
EXPECT_SUCCESS(s2n_connection_free(conn));
EXPECT_SUCCESS(s2n_hmac_init(&conn->secure.server_record_mac, S2N_HMAC_SHA1, mac_key, sizeof(mac_key)));
END_TEST();
}
static void
test_netaddr_is_in_subnet(void) {
struct netaddr_str str1, str2;
size_t a, s;
START_TEST();
for (s = 0; s < sizeof(in_subnet_subnets) / sizeof(*in_subnet_subnets); s++) {
for (a = 0; a < sizeof(in_subnet_addrs) / sizeof(*in_subnet_addrs); a++) {
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_binary_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a],
netaddr_get_maxprefix(&in_subnet_addrs[a])/8, in_subnet_addrs[a]._type),
"%s should %sbe in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
in_subnet_results[a][s] ? "" : "not ",
netaddr_to_string(&str2, &in_subnet_subnets[s]));
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a]),
"%s should %sbe in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
in_subnet_results[a][s] ? "" : "not ",
netaddr_to_string(&str2, &in_subnet_subnets[s]));
}
}
END_TEST();
}
int main(int argc, char **argv)
{
struct s2n_stuffer dhparams_in, dhparams_out;
struct s2n_dh_params dh_params;
struct s2n_blob b;
BEGIN_TEST();
EXPECT_EQUAL(s2n_get_private_random_bytes_used(), 0);
/* Parse the DH params */
b.data = dhparams;
b.size = sizeof(dhparams);
EXPECT_SUCCESS(s2n_stuffer_alloc(&dhparams_in, sizeof(dhparams)));
EXPECT_SUCCESS(s2n_stuffer_alloc(&dhparams_out, sizeof(dhparams)));
EXPECT_SUCCESS(s2n_stuffer_write(&dhparams_in, &b));
EXPECT_SUCCESS(s2n_stuffer_dhparams_from_pem(&dhparams_in, &dhparams_out));
b.size = s2n_stuffer_data_available(&dhparams_out);
b.data = s2n_stuffer_raw_read(&dhparams_out, b.size);
EXPECT_SUCCESS(s2n_pkcs3_to_dh_params(&dh_params, &b));
EXPECT_SUCCESS(s2n_dh_generate_ephemeral_key(&dh_params));
/* Verify that our DRBG is called and that over-riding works */
EXPECT_NOT_EQUAL(s2n_get_private_random_bytes_used(), 0);
EXPECT_SUCCESS(s2n_dh_params_free(&dh_params));
EXPECT_SUCCESS(s2n_stuffer_free(&dhparams_out));
EXPECT_SUCCESS(s2n_stuffer_free(&dhparams_in));
END_TEST();
}
static void
test_validate_fractional_minmax_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "10.0001");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed int out of range");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "10.0000");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive (border case)");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "9.9999");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive inside valid interval");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "-10.0001");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed int out of range");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "-10.0000");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive (border case)");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "fractional_minmax", "-9.9999");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive inside valid interval");
END_TEST();
}
void t02_several_add_methods(){
INIT_TEST();
onion_block *block=onion_block_new();
FAIL_IF_EQUAL(block, NULL);
int i;
for (i=0;i<1024;i++){
onion_block_add_char(block, (char)i);
}
onion_block_clear(block);
onion_block_add_str(block, "first ");
for (i=0;i<1024;i++)
onion_block_add_str(block, "test ");
FAIL_IF_NOT_STRSTR(onion_block_data(block), "test");
for (i=0;i<1024;i++)
onion_block_add_data(block, "world", 4);
FAIL_IF_STRSTR(onion_block_data(block), "world");
FAIL_IF_NOT_STRSTR(onion_block_data(block), "worl");
int s=onion_block_size(block);
onion_block_add_block(block, block);
FAIL_IF_NOT_EQUAL(onion_block_size(block), s+s);
onion_block_free(block);
END_TEST();
}
static void
test_default_named_section_set(void) {
const struct const_strarray *value;
START_TEST();
cfg_db_overwrite_entry(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_DEF, CFG_NAMED_VALUE);
cfg_db_overwrite_entry(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_NODEF, CFG_NAMED_VALUE);
value = cfg_db_get_entry_value(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_DEF);
CHECK_TRUE(value != NULL, "No value found for named section entry with default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_NAMED_VALUE) == 0,
"Did not got the named_section value with default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, CFG_SECTION_NAME, CFG_ENTRY_NODEF);
CHECK_TRUE(value != NULL, "No value found for named section entry without default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_NAMED_VALUE) == 0,
"Did not got the named_section value without default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, NULL, CFG_ENTRY_DEF);
CHECK_TRUE(value != NULL, "No value found for unnamed section entry with default");
if (value) {
CHECK_TRUE(value->value != NULL && strcmp(value->value, CFG_SCHEMA_DEFAULT) == 0,
"Did not got the named_section value with default: %s", value->value);
}
value = cfg_db_get_entry_value(db, CFG_SECTION, NULL, CFG_ENTRY_NODEF);
CHECK_TRUE(value == NULL, "value found for unnamed section entry without default: %s",
value == NULL ? "" : value->value);
END_TEST();
}
void test_simple_list_fill(struct test_list* _head) {
START_TEST();
CHECK_TRUE(_is_equal(_get_by_buffer(_head, bar), 42, bar), "%s", _print_result(_get_by_buffer(_head, bar)));
CHECK_TRUE(_is_equal(_get_by_value(_head, 23), 23, foo), "%s", _print_result(_get_by_value(_head, 23)));
END_TEST();
}
static void
test_validate_success(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
END_TEST();
}
void test_succeeds(PSMove *move) {
int i;
BEGIN_TEST("psmove_update_leds succeeds (rate limiting disabled)");
for (i=0; i<10; i++) {
psmove_set_leds(move, i, i, i);
assert(psmove_update_leds(move) == Update_Success);
}
END_TEST();
}
static void
test_str_to_isonumber_s64_2(void) {
struct isonumber_str buf;
START_TEST();
CHECK_TRUE(
isonumber_from_s64(&buf,
5185050545986994176ll, "bit/s", 0, true, false) != NULL, "test");
END_TEST();
}
void
FileOperationReadCacheTest::testOpenFile()
{
START_TEST(__func__);
CPPUNIT_ASSERT(pReadCacheManager!=NULL);
//CPPUNIT_ASSERT(pInterface!=NULL);
//CPPUNIT_ASSERT(pInterface->OpenFile(O_RDONLY));
END_TEST(__func__);
}
static void
test_simple_playback (IFusionSoundBuffer *buffer)
{
BEGIN_TEST( "Simple Playback" );
TEST(playback->Start (playback, 0, 0));
TEST(playback->Wait (playback));
END_TEST();
}
int main(int argc, char* argv[])
{
PSMove *move = psmove_connect();
int i;
if (move == NULL) {
printf("Could not connect to default Move controller.\n"
"Please connect one via USB or Bluetooth.\n");
exit(1);
}
INFO("Rate limiting is disabled by default");
test_succeeds(move);
INFO("Enabling rate limiting");
psmove_set_rate_limiting(move, 1);
BEGIN_TEST("psmove_update_leds ignores updates (rate limiting enabled)");
for (i=0; i<10; i++) {
psmove_set_leds(move, i, i, i);
assert(psmove_update_leds(move) == Update_Ignored);
}
END_TEST();
INFO("Disabling rate limiting");
psmove_set_rate_limiting(move, 0);
BEGIN_TEST("psmove_update_leds ignores updates (unchanged values)");
psmove_set_leds(move, 1, 1, 1);
assert(psmove_update_leds(move) == Update_Success);
for (i=0; i<10; i++) {
assert(psmove_update_leds(move) == Update_Ignored);
}
END_TEST();
test_succeeds(move);
psmove_disconnect(move);
return 0;
}
int main(int argc, char **argv)
{
unsigned char publicKey[BIKE1_L1_PUBLIC_KEY_BYTES];
unsigned char privateKey[BIKE1_L1_SECRET_KEY_BYTES];
unsigned char clientSharedSecretPlaintext[BIKE1_L1_SHARED_SECRET_BYTES];
unsigned char serverSharedSecretPlaintext[BIKE1_L1_SHARED_SECRET_BYTES];
unsigned char encryptedSecret[BIKE1_L1_CIPHERTEXT_BYTES];
BEGIN_TEST();
// BIKE is not supported in FIPS mode
if (s2n_is_in_fips_mode()) {
END_TEST();
}
EXPECT_SUCCESS(BIKE1_L1_crypto_kem_keypair(publicKey, privateKey));
EXPECT_SUCCESS(BIKE1_L1_crypto_kem_enc(encryptedSecret, clientSharedSecretPlaintext, publicKey));
EXPECT_SUCCESS(BIKE1_L1_crypto_kem_dec(serverSharedSecretPlaintext, encryptedSecret, privateKey));
EXPECT_BYTEARRAY_EQUAL(serverSharedSecretPlaintext, clientSharedSecretPlaintext, BIKE1_L1_SHARED_SECRET_BYTES);
END_TEST();
}
void test_simple_list_remove(struct test_list** __head) {
struct test_list* _head;
simple_list_remove(__head, _get_by_buffer(*__head, foo));
_head = *__head;
START_TEST();
CHECK_TRUE(_is_equal(_head, 42, bar), "%s", _print_result(_head));
CHECK_TRUE(_is_equal(_head->next, 1337, baz), "%s", _print_result(_head->next));
END_TEST();
}
static void
test_validate_stringarray_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "stringarray", "12345678");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed too long string value");
END_TEST();
}
static void
test_validate_printable_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "printable", "1234\n5678");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed non-printable character");
END_TEST();
}
void test_simple_list_find(struct test_list* _head) {
char buffer[sizeof bar];
memcpy(buffer, bar, sizeof buffer);
START_TEST();
CHECK_TRUE(_is_equal(simple_list_find_memcmp(_head, buffer), 42, bar), "%s", _print_result(simple_list_find_memcmp(_head, buffer)));
CHECK_TRUE(_is_equal(simple_list_find_cmp(_head, buffer, (int (*)(void *, void *)) strcmp), 42, bar),
"%s", _print_result(simple_list_find_cmp(_head, buffer, (int (*)(void *, void *)) strcmp)));
END_TEST();
}
static void
test_validate_choice_miss(void) {
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, "choice", "choice42");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, NULL),
"validation missed bad choice");
END_TEST();
}
static void
test_looping_playback (IFusionSoundBuffer *buffer)
{
BEGIN_TEST( "Looping Playback" );
TEST(playback->Start (playback, 0, -1));
sleep (5);
TEST(playback->Stop (playback));
END_TEST();
}
int main(int argc, char **argv)
{
struct s2n_connection *conn;
BEGIN_TEST();
EXPECT_NULL(conn = s2n_connection_new(S2N_CLIENT));
EXPECT_SUCCESS(setenv("S2N_ENABLE_CLIENT_MODE", "1", 0));
EXPECT_NOT_NULL(conn = s2n_connection_new(S2N_CLIENT));
EXPECT_SUCCESS(s2n_connection_free(conn));
END_TEST();
}
static void
test_delta_remove_single_section(void) {
START_TEST();
handler_1.cb_delta_handler = handler_remove_section;
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_1, KEY_1, value_1.value);
cfg_db_add_entry(db_pre, SECTION_TYPE_1, NAME_1, KEY_2, value_2.value);
CHECK_TRUE(cfg_schema_handle_db_changes(db_pre, db_post) == 0,
"delta calculation failed");
CHECK_TRUE(callback_counter == 1, "Callback counter was called %d times", callback_counter);
END_TEST();
}
static void
test_positioned_playback (IFusionSoundBuffer *buffer)
{
FSBufferDescription desc;
BEGIN_TEST( "Positioned Playback" );
TEST(buffer->GetDescription (buffer, &desc));
TEST(playback->Start (playback, desc.length * 1/3, desc.length * 1/4));
TEST(playback->Wait (playback));
END_TEST();
}
void t01_create_and_free(){
INIT_TEST();
onion_block *block=onion_block_new();
FAIL_IF_EQUAL(block, NULL);
int i;
for (i=0;i<16*1024;i++){
onion_block_add_char(block, (char)i);
}
onion_block_free(block);
END_TEST();
}
static void
test_validate_netaddr_ipv46_prefix_miss(void) {
const char *key = "p_ipv46";
START_TEST();
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"%s", abuf_getptr(&out));
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "xxxxxxx");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad address");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10:00:00:00:00:00");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad mac48");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "11-22-33-44-55-66-77-88");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad eui64");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10.0.0.1");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv4");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10::1");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv6");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10:00:00:00:00:00/10");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad mac48 prefix");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "11-22-33-44-55-66-77-88/11");
CHECK_TRUE(0 != cfg_schema_validate(db, false, false, &out),
"validation missed with bad eui64 prefix");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10.0.0.1/12");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv4 prefix");
cfg_db_add_entry(db, CFG_SEC, CFG_SECNAME, key, "10::1/13");
CHECK_TRUE(0 == cfg_schema_validate(db, false, false, &out),
"validation had false positive with ipv6 prefix");
END_TEST();
}
static void
test_volume_level (IFusionSoundBuffer *buffer)
{
int i;
BEGIN_TEST( "Volume Level" );
TEST(playback->Start (playback, 0, 0));
for (i=0; i<150; i++) {
TEST(playback->SetVolume (playback, sin (i/3.0) / 3.0f + 0.6f ));
usleep (20000);
}
END_TEST();
}
static void
test_pan_value (IFusionSoundBuffer *buffer)
{
int i;
BEGIN_TEST( "Pan Value" );
TEST(playback->Start (playback, 0, 0));
for (i=0; i<150; i++) {
TEST(playback->SetPan (playback, sin (i/3.0)));
usleep (20000);
}
END_TEST();
}
static void
test_pitch_value (IFusionSoundBuffer *buffer)
{
int i;
BEGIN_TEST( "Pitch Value" );
TEST(playback->Start (playback, 0, -1));
for (i=500; i<1500; i++) {
TEST(playback->SetPitch (playback, i/1000.0f));
usleep (20000);
}
END_TEST();
}
