void
test_udp_declare(void) {
	ADD_TEST(udp, stream_ipv4);
	ADD_TEST(udp, stream_ipv6);
	ADD_TEST(udp, datagram_ipv4);
	ADD_TEST(udp, datagram_ipv6);
}

static void
test_error_declare(void) {
	ADD_TEST(error, error);
	ADD_TEST(error, context);
	ADD_TEST(error, thread);
	ADD_TEST(error, output);
}

static void
test_exception_declare(void) {
    ADD_TEST(exception, assert_handler);
    ADD_TEST(exception, error);
    ADD_TEST(exception, exception_handler);
    ADD_TEST(exception, exception_thread);
}

void test_ringbuffer_declare( void )
{
	ADD_TEST( ringbuffer, allocate );
	ADD_TEST( ringbuffer, io );

	ADD_TEST( ringbufferstream, threadedio );
}

QuadInterptest::QuadInterptest()
{
  ADD_TEST(QuadInterptest::test_QuadInterp);
  ADD_TEST(QuadInterptest::test_flat);
  ADD_TEST(QuadInterptest::test_calc);
  ADD_TEST(QuadInterptest::test_calc_nocalc);
}

void test_declare( void )
{
	ADD_TEST( hashmap, allocation );
	ADD_TEST( hashmap, insert );
	ADD_TEST( hashmap, erase );
	ADD_TEST( hashmap, lookup );
}

int setup_tests(void)
{
#ifndef OPENSSL_NO_BF
# ifdef CHARSET_EBCDIC
    int n;

    ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data));
    for (n = 0; n < 2; n++) {
        ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n]));
    }
# endif

    if (test_get_argument(0) != NULL) {
        print_test_data();
    } else {
        ADD_ALL_TESTS(test_bf_ecb_raw, 2);
        ADD_ALL_TESTS(test_bf_ecb, NUM_TESTS);
        ADD_ALL_TESTS(test_bf_set_key, KEY_TEST_NUM-1);
        ADD_TEST(test_bf_cbc);
        ADD_TEST(test_bf_cfb64);
        ADD_TEST(test_bf_ofb64);
    }
#endif
    return 1;
}

void o_url_resolve_suite()
{
	ADD_TEST(test_o_url_resolve_type, "Test a resolve of type from url");
	ADD_TEST(test_o_url_resolve_information, "Test a url resolver information");
	ADD_TEST(test_o_url_resolve_host_port_from_path, "Test a host and port resolve from path");
	ADD_TEST(test_o_url_resolve_host_from_path, "Test an only host resolve from path");
}

static void test_profile_declare( void )
{
	ADD_TEST( profile, initialize );
	ADD_TEST( profile, output );
	ADD_TEST( profile, thread );
	ADD_TEST( profile, stream );
}

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    TestRunner &runner = *(new TestRunner());

    qDebug() << app.arguments();

    bool all = (app.arguments().size() <= 1);

#define ADD_TEST(TestName)                                                     \
    qDebug() << "Test " << #TestName << " is enabled "                         \
             << (all || app.arguments().contains(#TestName));                  \
    if (all || app.arguments().contains(#TestName)) {                          \
        runner << new TestName##Test();                                        \
    }

    ADD_TEST(Query)
    ADD_TEST(ResultSet)
    ADD_TEST(ResultSetQuickCheck)
    ADD_TEST(ResultWatcher)

    runner.start();

#undef ADD_TEST
    return app.exec();
    // QTest::qExec(&tc, argc, argv);
}

int main(int argc, char **argv)
{
    ADD_TEST(test_tbl_standard);
    ADD_TEST(test_standard_methods);

    return run_tests(argv[0]);
}

Linktest::Linktest()
{
    ADD_TEST(Linktest::test_send);
    ADD_TEST(Linktest::test_send_connected);
    ADD_TEST(Linktest::test_sendError);
    ADD_TEST(Linktest::test_sendError_connected);
    ADD_TEST(Linktest::test_disconnect);
}

static void test_event_declare( void )
{
	ADD_TEST( event, empty );
	ADD_TEST( event, immediate );
	ADD_TEST( event, delay );
	ADD_TEST( event, immediate_threaded );
	ADD_TEST( event, delay_threaded );
}

int setup_tests(void)
{
    ADD_TEST(test_int_stack);
    ADD_TEST(test_uchar_stack);
    ADD_TEST(test_SS_stack);
    ADD_TEST(test_SU_stack);
    return 1;
}

Planttest::Planttest()
{
  ADD_TEST(Planttest::test_getDisplacement);
  ADD_TEST(Planttest::test_setDisplacement_wfmath);
  ADD_TEST(Planttest::test_setDisplacement);
  ADD_TEST(Planttest::test_getOrientation);
  ADD_TEST(Planttest::test_setHeight);
}

int setup_tests(void)
{
    ADD_TEST(test_builtin_provider);
#ifndef OPENSSL_NO_MODULE
    ADD_TEST(test_loaded_provider);
#endif
    return 1;
}

int setup_tests(void)
{
    ADD_TEST(test_builtin_provider);
#ifndef NO_PROVIDER_MODULE
    ADD_TEST(test_loaded_provider);
    ADD_TEST(test_configured_provider);
#endif
    return 1;
}

	FGameplayEffectsTest(const FString& InName)
	: FAutomationTestBase(InName, false)
	{
		// list all test functions here
		ADD_TEST(Test_InstantDamage);
		ADD_TEST(Test_InstantDamageRemap);
		ADD_TEST(Test_ManaBuff);
		ADD_TEST(Test_PeriodicDamage);
	}

int setup_tests(void)
{
    ADD_TEST(test_kdf_tls1_prf);
    ADD_TEST(test_kdf_hkdf);
#ifndef OPENSSL_NO_SCRYPT
    ADD_TEST(test_kdf_scrypt);
#endif
    return 1;
}

void register_tests(void)
{
#ifdef OPENSSL_NO_SRP
    printf("No SRP support\n");
#else
    ADD_TEST(run_srp_tests);
    ADD_TEST(run_srp_kat);
#endif
}