void AddTests(const long double &)
 {
   // add the tests
   TEST_ADD(minimum_distance_point_test_suite<long double>::simple_1d_test);
   TEST_ADD(minimum_distance_point_test_suite<long double>::simple_2d_test);
   TEST_ADD(minimum_distance_point_test_suite<long double>::simple_3d_test);
 }
 void AddTests(const float &)
 {
   // add the tests
   TEST_ADD(minimum_distance_point_test_suite<float>::simple_1d_test);
   TEST_ADD(minimum_distance_point_test_suite<float>::simple_2d_test);
   TEST_ADD(minimum_distance_point_test_suite<float>::simple_3d_test);
 }
Пример #3
0
TestUtility::TestUtility()
{
    TEST_ADD(TestUtility::printDomainInfo);
    TEST_ADD(TestUtility::testNetworkInfo);
    TEST_ADD(TestUtility::testTrim);
    TEST_ADD(TestUtility::testEqualsIgnoreCase);
}
Пример #4
0
TestParameters::TestParameters() : params({},{})
{
    TEST_ADD(TestParameters::testParseParameters);
    TEST_ADD(TestParameters::testIsParameterSet);
    TEST_ADD(TestParameters::testGetParameterValue);
    TEST_ADD(TestParameters::testGetAudioProcessors);
}
Пример #5
0
StepOneThreadSuite::StepOneThreadSuite()
{
    TEST_ADD( StepOneThreadSuite::StepInstructionInAssembly );
    TEST_ADD( StepOneThreadSuite::StepInstructionOver );
    TEST_ADD( StepOneThreadSuite::StepInstructionInSourceHaveSource );
    TEST_ADD( StepOneThreadSuite::StepInstructionInSourceNoSource );
    TEST_ADD( StepOneThreadSuite::StepInstructionOverInterruptedByBP );
}
Пример #6
0
 void AddTests(const long double &)
 {
   // add the tests
   TEST_ADD(cst_airfoil_test_suite<long double>::assignment_test);
   TEST_ADD(cst_airfoil_test_suite<long double>::evaluation_test);
   TEST_ADD(cst_airfoil_test_suite<long double>::derivative_test);
   TEST_ADD(cst_airfoil_test_suite<long double>::promotion_test);
   TEST_ADD(cst_airfoil_test_suite<long double>::demotion_test);
 }
Пример #7
0
 void AddTests(const float &)
 {
   // add the tests
   TEST_ADD(cst_airfoil_test_suite<float>::assignment_test);
   TEST_ADD(cst_airfoil_test_suite<float>::evaluation_test);
   TEST_ADD(cst_airfoil_test_suite<float>::derivative_test);
   TEST_ADD(cst_airfoil_test_suite<float>::promotion_test);
   TEST_ADD(cst_airfoil_test_suite<float>::demotion_test);
 }
Пример #8
0
RequestSuite::RequestSuite() {
	sAppLog.SetLogLevel(Logger::DEBUG);
#if 1
	TEST_ADD(RequestSuite::TestManyGoodGets);

	TEST_ADD(RequestSuite::TestRequestConnectionKeepAlive);
//	TEST_ADD(RequestSuite::TestEvilRequests);
	TEST_ADD(RequestSuite::TestMandatoryHeaderMissing);
//	TEST_ADD(RequestSuite::TestMultilineHeaders);
#endif
	TEST_ADD(RequestSuite::TestReqeustsByteForByte);
}
Пример #9
0
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);


    QVector<QObject *> tests;


    TEST_ADD(MaterialTest);
    TEST_ADD(MeshTest);
    TEST_ADD(NewtonDamperTest);



    int ret = 0;
    foreach (QObject* test, tests) {
        ret = ret | QTest::qExec(test);
    }
int main (int   argc,
          char *argv[])
{
    g_type_init ();
    g_test_init (&argc, &argv, NULL);

    TEST_ADD ("/MM/Service/Generic", test_something);

    return g_test_run ();
}
Пример #11
0
		/**
		The constructor needs the add each test method for the non-VS unit test execution.
		*/
		StringUtilTest()
		{
			TEST_ADD(StringUtilTest::testStringUtilTrue);
/*
			TEST_ADD(StringUtilTest::testStringUtilStdLibToUpper);
			TEST_ADD(StringUtilTest::testStringUtilStrlen);
			TEST_ADD(StringUtilTest::testStringUtilCopyUpper);
			TEST_ADD(StringUtilTest::testStringUtilStdLibToUpper);
			TEST_ADD(StringUtilTest::testStringUtilStdLibStrlen);
*/
		}
 void AddTests(const long double &)
 {
   // add the tests
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::assignment_test);
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::reverse_test);
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::evaluation_test);
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::derivative_test);
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::promotion_test);
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::demotion_test);
   TEST_ADD(explicit_bezier_curve_test_suite<long double>::length_test);
 }
Пример #13
0
TestPi::TestPi(void)
    {
    this->n=INT_MAX/10;

    TEST_ADD(TestPi::testSequentiel);

    TEST_ADD(TestPi::testEntrelacerPromotionTab);
    TEST_ADD(TestPi::testEntrelacerAtomic);
    TEST_ADD(TestPi::testEntrelacerCritical);

    TEST_ADD(TestPi::testAtomic);
    TEST_ADD(TestPi::testCritical);
    TEST_ADD(TestPi::testPromotionTab);
    TEST_ADD(TestPi::testForReduction);
    }
Пример #14
0
 GMTS() {
     TEST_ADD(GMTS::basic_constructors);
     TEST_ADD(GMTS::create_group);
     TEST_ADD(GMTS::key_resolution);
     TEST_ADD(GMTS::add_users);
     TEST_ADD(GMTS::user_table);
     TEST_ADD(GMTS::remove_users);
 }
Пример #15
0
Файл: test.c Проект: jonmann20/C
int TEST_ALL(){
	plan(3 + 1 + 13);

	TEST_ADD();
	TEST_SUBTRACT();
	TEST_FIBONACCI();

	todo();
	ok(0, "finish this project");
	end_todo;


	done_testing();
}
Пример #16
0
 void AddTests(const long double &)
 {
   TEST_ADD(nls_test_suite<long double>::bisection_method_test);
   TEST_ADD(nls_test_suite<long double>::newton_raphson_method_test);
   TEST_ADD(nls_test_suite<long double>::secant_method_test);
   TEST_ADD(nls_test_suite<long double>::newton_raphson_constrained_method_test);
   TEST_ADD(nls_test_suite<long double>::newton_raphson_system_method_test);
   TEST_ADD(nls_test_suite<long double>::newton_raphson_constrained_system_method_test);
 }
Пример #17
0
 void AddTests(const float &)
 {
   TEST_ADD(nls_test_suite<float>::bisection_method_test);
   TEST_ADD(nls_test_suite<float>::newton_raphson_method_test);
   TEST_ADD(nls_test_suite<float>::secant_method_test);
   TEST_ADD(nls_test_suite<float>::newton_raphson_constrained_method_test);
   TEST_ADD(nls_test_suite<float>::newton_raphson_system_method_test);
   TEST_ADD(nls_test_suite<float>::newton_raphson_constrained_system_method_test);
 }
Пример #18
0
    UserManagerTestSuite()
    {
        flushdb();

        TEST_ADD(UserManagerTestSuite::register_new_user);
        TEST_ADD(UserManagerTestSuite::register_existing_user);
        TEST_ADD(UserManagerTestSuite::login_existing_success);
        TEST_ADD(UserManagerTestSuite::login_nonexisting_user);
        TEST_ADD(UserManagerTestSuite::login_existing_fail);
        //Make sure case sensitivity is not bound to usernames
        TEST_ADD(UserManagerTestSuite::login_existing_CAPS_success);
        //Make sure case sensitivity is bound to passwords
        TEST_ADD(UserManagerTestSuite::login_existing_CAPS_fail);
    }
Пример #19
0
int main(int argc, char** argv)
{
	auto in = std::ifstream("../test.kl", std::ios::in | std::ios::binary);
	auto input = std::string(
		std::istreambuf_iterator<char>(in),
		std::istreambuf_iterator<char>()
	);

	in.close();

	auto lexer = std::make_shared<Lexer>(input.c_str());
	auto parser = std::make_shared<Parser>(lexer);
	auto translator = std::make_shared<Translator>(parser);

	if (lexer->Failed)
	{
		std::cout << lexer->Error << std::endl;
		return -1;
	}
	
	lexer->Print();

	if (parser->Failed)
	{
		std::cout << parser->Error << std::endl;
		return -1;
	}

	parser->Print();
	//translator->Print();

	WriterText writer;

	writer.Write(translator->Root());

	return 0;

	VM vm;

	vm.init();

	TEST_INIT();

	TEST_ADD(test_assign_literal, &vm);
	TEST_ADD(test_assign_literal_multi, &vm);
	TEST_ADD(test_assign_from_local, &vm);
	TEST_ADD(test_func_decl, &vm);
	TEST_ADD(test_func_call_fake, &vm);
	TEST_ADD(test_int_ptr, &vm);
	TEST_ADD(test_arithmetic, &vm);

	//TEST_ADD(test_ip_simple, &vm);
	TEST_ADD(test_func_call_real, &vm);

	TEST_RUN();

	TEST_RELEASE();

	vm.release();

	return 0;
}
Пример #20
0
 DeltaCompressTest( ) {
    TEST_ADD(DeltaCompressTest::ConstructDeltaCompress);
    // TEST_ADD(DeltaCompressTest::sortIndexesTest);
 } 
 void AddTests(const long double &)
 {
   // add the tests
   TEST_ADD(piecewise_polynomial_creator_test_suite<long double>::create_curve_test);
   TEST_ADD(piecewise_polynomial_creator_test_suite<long double>::full_cycle_test);
 }
 void AddTests(const float &)
 {
   // add the tests
   TEST_ADD(piecewise_polynomial_creator_test_suite<float>::create_curve_test);
   TEST_ADD(piecewise_polynomial_creator_test_suite<float>::full_cycle_test);
 }
Пример #23
0
void TEST_ALL(){
	TEST_ADD();
	TEST_SUBTRACT();
	TEST_FIBONACCI();
}
Пример #24
0
 TestSuite()
 {
     TEST_ADD(TestSuite::SetInteger);
     TEST_ADD(TestSuite::SetFloat);
     TEST_ADD(TestSuite::SetDouble);
     TEST_ADD(TestSuite::SetBoolean);
     TEST_ADD(TestSuite::SetString);
     TEST_ADD(TestSuite::CallFunction);
     TEST_ADD(TestSuite::CallConstRefrenceMethod);
     TEST_ADD(TestSuite::CallMethodWithPointerParam);
     TEST_ADD(TestSuite::CallConstRefrenceMethodWithNoReturn);
     //TEST_ADD(TestSuite::CallRefrenceMethod);
     TEST_ADD(TestSuite::DoStuffWithOtherPointer);
     TEST_ADD(TestSuite::VerifyConstRefCalling);
     TEST_ADD(TestSuite::CallConstructorWithParameters);
     TEST_ADD(TestSuite::CallConstructorWithBindedClass);
     TEST_ADD(TestSuite::TestStdStringParameter);
     TEST_ADD(TestSuite::TestLuaFieldAssign);
     TEST_ADD(TestSuite::TestLuaInstanceAssign);
 }
Пример #25
0
 DeltaBlockTest( ) {
    TEST_ADD(DeltaBlockTest::ConstructDeltaBlock);
 } 
 void AddTests(const long double &)
 {
   // add the tests
   TEST_ADD(piecewise_capped_surface_creator_test_suite<long double>::create_flat_capped_surface_test);
 }
Пример #27
0
	TEST_ASSERT_MSG( ! t.frecuenciaInvalida( FREC_MAX + 1 ),
	                 "4.3 Hz NO es una frecuencia peligrosa, y se detecta como si lo fuera");

	TEST_ASSERT_MSG( ! t.frecuenciaInvalida( FREC_MIN - 1 ),
	                 "1.7 Hz NO es una frecuencia peligrosa, y se detecta como si lo fuera");
}

void TemblorTestSuite::testSeCaeTodo() {
	Entrada e(ARCHIVO_DE_ENTRADA_3);
	Temblor t(&e);

	// El archivo de prueba tiene 3 pisos, así que pongo 3 frecuencias
	FLOTANTE frecNoSeCae[] = { 3.4, 2.6, 5 };
	TEST_ASSERT_MSG( ! t.seCaeTodo( frecNoSeCae ),
	                 "Oops, todo se cae y no debería");

	FLOTANTE frecHacePumba[] = { 3.0, 2.6, 5 };
	TEST_ASSERT_MSG( t.seCaeTodo( frecHacePumba ),
	                 "Oops, dice que no pasa nada pero todo se cae");


}
TemblorTestSuite::TemblorTestSuite() {
	TEST_ADD(TemblorTestSuite::testSeCaeTodo)
	TEST_ADD(TemblorTestSuite::testFrecPeligrosa)
}

TemblorTestSuite::~TemblorTestSuite() {
}
#ifndef SUDOKU_STARELIMINATIONBYSTARTESTSUITE
#define SUDOKU_STARELIMINATIONBYSTARTESTSUITE

#include"equalityTestSuite.hpp"

class starEliminationbyStarTestSuite : public equalityTestSuite {
public:
	starEliminationbyStarTestSuite()
	{
		TEST_ADD(starEliminationbyStarTestSuite::rowByBlocksPositive)
		TEST_ADD(starEliminationbyStarTestSuite::rowByBlocksNegative)
		TEST_ADD(starEliminationbyStarTestSuite::blockByRowsPositive)
		TEST_ADD(starEliminationbyStarTestSuite::blockByRowsNegative)
		TEST_ADD(starEliminationbyStarTestSuite::columnByBlocksPositive)
		TEST_ADD(starEliminationbyStarTestSuite::columnByBlocksNegative)
		TEST_ADD(starEliminationbyStarTestSuite::blockByColumnsPositive)
		TEST_ADD(starEliminationbyStarTestSuite::blockByColumnsNegative)
	}
	
private:
	void rowByBlocksPositive();
	void rowByBlocksNegative();
	void blockByRowsPositive();
	void blockByRowsNegative();
	void columnByBlocksPositive();
	void columnByBlocksNegative();
	void blockByColumnsPositive();
	void blockByColumnsNegative();
};

#endif
 void AddTests(const float &)
 {
   // add the tests
   TEST_ADD(piecewise_capped_surface_creator_test_suite<float>::create_flat_capped_surface_test);
 }
Пример #30
0
IntersectionUnitTests::IntersectionUnitTests()
{
    TEST_ADD(IntersectionUnitTests::IntersectionTest);
    TEST_ADD(IntersectionUnitTests::IntersectionTestFail);
    TEST_ADD(IntersectionUnitTests::IntersectionTestBoundaryPass);
}