C++ END_TEST函数代码示例

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