simdjson 0.2.0 → 0.3.0

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestMacros.h

@@ -0,0 +1,113 @@
+#ifndef UNITTEST_TESTMACROS_H
+#define UNITTEST_TESTMACROS_H
+
+#include "Config.h"
+#include "ExecuteTest.h"
+#include "AssertException.h"
+#include "TestDetails.h"
+#include "MemoryOutStream.h"
+
+#ifndef UNITTEST_POSIX
+	#define UNITTEST_THROW_SIGNALS
+#else
+	#include "Posix/SignalTranslator.h"
+#endif
+
+#ifdef TEST
+    #error UnitTest++ redefines TEST
+#endif
+
+#ifdef TEST_EX
+	#error UnitTest++ redefines TEST_EX
+#endif
+
+#ifdef TEST_FIXTURE_EX
+	#error UnitTest++ redefines TEST_FIXTURE_EX
+#endif
+
+#define SUITE(Name)                                                         \
+	namespace Suite##Name {                                                        \
+        namespace UnitTestSuite {                                           \
+            inline char const* GetSuiteName () {                            \
+                return #Name ;                                              \
+            }                                                               \
+        }                                                                   \
+    }                                                                       \
+	namespace Suite##Name
+
+#define TEST_EX(Name, List)                                                \
+    class Test##Name : public UnitTest::Test                               \
+    {                                                                      \
+    public:                                                                \
+		Test##Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {}  \
+    private:                                                               \
+        virtual void RunImpl() const;   \
+    } test##Name##Instance;                                                \
+																		   \
+    UnitTest::ListAdder adder##Name (List, &test##Name##Instance);         \
+																		   \
+    void Test##Name::RunImpl() const
+
+
+#define TEST(Name) TEST_EX(Name, UnitTest::Test::GetTestList())
+
+
+#define TEST_FIXTURE_EX(Fixture, Name, List)                                         \
+    class Fixture##Name##Helper : public Fixture									 \
+	{																				 \
+	public:																			 \
+        explicit Fixture##Name##Helper(UnitTest::TestDetails const& details) : m_details(details) {} \
+        void RunImpl();                           \
+        UnitTest::TestDetails const& m_details;                                      \
+    private:                                                                         \
+        Fixture##Name##Helper(Fixture##Name##Helper const&);                         \
+        Fixture##Name##Helper& operator =(Fixture##Name##Helper const&);             \
+    };                                                                               \
+																					 \
+    class Test##Fixture##Name : public UnitTest::Test                                \
+    {                                                                                \
+    public:                                                                          \
+	    Test##Fixture##Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {} \
+    private:                                                                         \
+        virtual void RunImpl() const;             \
+    } test##Fixture##Name##Instance;                                                 \
+																					 \
+    UnitTest::ListAdder adder##Fixture##Name (List, &test##Fixture##Name##Instance); \
+																					 \
+    void Test##Fixture##Name::RunImpl() const	 \
+	{																				 \
+		bool ctorOk = false;														 \
+		try {																		 \
+			Fixture##Name##Helper fixtureHelper(m_details);							 \
+			ctorOk = true;															 \
+			UnitTest::ExecuteTest(fixtureHelper, m_details);					 \
+		}																			 \
+		catch (UnitTest::AssertException const& e)											 \
+		{																			 \
+			UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(m_details.testName, m_details.suiteName, e.Filename(), e.LineNumber()), e.what()); \
+		}																			 \
+		catch (std::exception const& e)												 \
+		{																			 \
+			UnitTest::MemoryOutStream stream;													 \
+			stream << "Unhandled exception: " << e.what();							 \
+			UnitTest::CurrentTest::Results()->OnTestFailure(m_details, stream.GetText());				 \
+		}																			 \
+		catch (...) {																 \
+			if (ctorOk)																 \
+			{																		 \
+	            UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(m_details, __LINE__),	 \
+					"Unhandled exception while destroying fixture " #Fixture);		 \
+			}																		 \
+			else																	 \
+			{																		 \
+				UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(m_details, __LINE__),   \
+					"Unhandled exception while constructing fixture " #Fixture);         \
+			}																		 \
+		}																			 \
+    }                                                                                \
+    void Fixture##Name##Helper::RunImpl()
+
+#define TEST_FIXTURE(Fixture,Name) TEST_FIXTURE_EX(Fixture, Name, UnitTest::Test::GetTestList())
+
+
+#endif

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestReporter.cpp

@@ -0,0 +1,10 @@
+#include "TestReporter.h"
+
+namespace UnitTest {
+
+
+TestReporter::~TestReporter()
+{
+}
+
+}

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestReporter.h

@@ -0,0 +1,20 @@
+#ifndef UNITTEST_TESTREPORTER_H
+#define UNITTEST_TESTREPORTER_H
+
+namespace UnitTest {
+
+class TestDetails;
+
+class TestReporter
+{
+public:
+    virtual ~TestReporter();
+
+    virtual void ReportTestStart(TestDetails const& test) = 0;
+    virtual void ReportFailure(TestDetails const& test, char const* failure) = 0;
+    virtual void ReportTestFinish(TestDetails const& test, float secondsElapsed) = 0;
+    virtual void ReportSummary(int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed) = 0;
+};
+
+}
+#endif

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestReporterStdout.cpp

@@ -0,0 +1,41 @@
+#include "TestReporterStdout.h"
+#include <cstdio>
+
+#include "TestDetails.h"
+
+namespace UnitTest {
+
+void TestReporterStdout::ReportFailure(TestDetails const& details, char const* failure)
+{
+#if defined(__APPLE__) || defined(__GNUG__)
+    char const* const errorFormat = "%s:%d: error: Failure in %s: %s\n";
+#else
+    char const* const errorFormat = "%s(%d): error: Failure in %s: %s\n";
+#endif
+
+	using namespace std;
+    printf(errorFormat, details.filename, details.lineNumber, details.testName, failure);
+}
+
+void TestReporterStdout::ReportTestStart(TestDetails const& /*test*/)
+{
+}
+
+void TestReporterStdout::ReportTestFinish(TestDetails const& /*test*/, float)
+{
+}
+
+void TestReporterStdout::ReportSummary(int const totalTestCount, int const failedTestCount,
+                                       int const failureCount, float secondsElapsed)
+{
+	using namespace std;
+
+    if (failureCount > 0)
+        printf("FAILURE: %d out of %d tests failed (%d failures).\n", failedTestCount, totalTestCount, failureCount);
+    else
+        printf("Success: %d tests passed.\n", totalTestCount);
+
+    printf("Test time: %.2f seconds.\n", secondsElapsed);
+}
+
+}

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestReporterStdout.h

@@ -0,0 +1,19 @@
+#ifndef UNITTEST_TESTREPORTERSTDOUT_H
+#define UNITTEST_TESTREPORTERSTDOUT_H
+
+#include "TestReporter.h"
+
+namespace UnitTest {
+
+class TestReporterStdout : public TestReporter
+{
+private:
+    virtual void ReportTestStart(TestDetails const& test);
+    virtual void ReportFailure(TestDetails const& test, char const* failure);
+    virtual void ReportTestFinish(TestDetails const& test, float secondsElapsed);
+    virtual void ReportSummary(int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed);
+};
+
+}
+
+#endif 

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestResults.cpp

@@ -0,0 +1,60 @@
+#include "TestResults.h"
+#include "TestReporter.h"
+
+#include "TestDetails.h"
+
+namespace UnitTest {
+
+TestResults::TestResults(TestReporter* testReporter)
+    : m_testReporter(testReporter)
+    , m_totalTestCount(0)
+    , m_failedTestCount(0)
+    , m_failureCount(0)
+    , m_currentTestFailed(false)
+{
+}
+
+void TestResults::OnTestStart(TestDetails const& test)
+{
+    ++m_totalTestCount;
+    m_currentTestFailed = false;
+    if (m_testReporter)
+        m_testReporter->ReportTestStart(test);
+}
+
+void TestResults::OnTestFailure(TestDetails const& test, char const* failure)
+{
+    ++m_failureCount;
+    if (!m_currentTestFailed)
+    {
+        ++m_failedTestCount;
+        m_currentTestFailed = true;
+    }
+
+    if (m_testReporter)
+        m_testReporter->ReportFailure(test, failure);
+}
+
+void TestResults::OnTestFinish(TestDetails const& test, float secondsElapsed)
+{
+    if (m_testReporter)
+        m_testReporter->ReportTestFinish(test, secondsElapsed);
+}
+
+int TestResults::GetTotalTestCount() const
+{
+    return m_totalTestCount;
+}
+
+int TestResults::GetFailedTestCount() const
+{
+    return m_failedTestCount;
+}
+
+int TestResults::GetFailureCount() const
+{
+    return m_failureCount;
+}
+
+
+}

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestResults.h

@@ -0,0 +1,36 @@
+#ifndef UNITTEST_TESTRESULTS_H
+#define UNITTEST_TESTRESULTS_H
+
+namespace UnitTest {
+
+class TestReporter;
+class TestDetails;
+
+class TestResults
+{
+public:
+    explicit TestResults(TestReporter* reporter = 0);
+
+    void OnTestStart(TestDetails const& test);
+    void OnTestFailure(TestDetails const& test, char const* failure);
+    void OnTestFinish(TestDetails const& test, float secondsElapsed);
+
+    int GetTotalTestCount() const;
+    int GetFailedTestCount() const;
+    int GetFailureCount() const;
+
+private:
+    TestReporter* m_testReporter;
+    int m_totalTestCount;
+    int m_failedTestCount;
+    int m_failureCount;
+
+    bool m_currentTestFailed;
+
+    TestResults(TestResults const&);
+    TestResults& operator =(TestResults const&);
+};
+
+}
+
+#endif

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestRunner.cpp

@@ -0,0 +1,76 @@
+#include "TestRunner.h"
+#include "TestResults.h"
+#include "TestReporter.h"
+#include "TestReporterStdout.h"
+#include "TimeHelpers.h"
+#include "MemoryOutStream.h"
+
+#include <cstring>
+
+
+namespace UnitTest {
+
+int RunAllTests()
+{
+	TestReporterStdout reporter;
+	TestRunner runner(reporter);
+	return runner.RunTestsIf(Test::GetTestList(), NULL, True(), 0);
+}
+
+
+TestRunner::TestRunner(TestReporter& reporter)
+	: m_reporter(&reporter)
+	, m_result(new TestResults(&reporter))
+	, m_timer(new Timer)
+{
+	m_timer->Start();
+}
+
+TestRunner::~TestRunner()
+{
+	delete m_result;
+	delete m_timer;
+}
+
+int TestRunner::Finish() const
+{
+    float const secondsElapsed = m_timer->GetTimeInMs() / 1000.0f;
+    m_reporter->ReportSummary(m_result->GetTotalTestCount(), 
+							  m_result->GetFailedTestCount(), 
+							  m_result->GetFailureCount(), 
+							  secondsElapsed);
+    
+	return m_result->GetFailureCount();
+}
+
+bool TestRunner::IsTestInSuite(const Test* const curTest, char const* suiteName) const
+{
+	using namespace std;
+	return (suiteName == NULL) || !strcmp(curTest->m_details.suiteName, suiteName);
+}
+
+void TestRunner::RunTest(TestResults* const result, Test* const curTest, int const maxTestTimeInMs) const
+{
+	CurrentTest::Results() = result;
+
+	Timer testTimer;
+	testTimer.Start();
+
+	result->OnTestStart(curTest->m_details);
+
+	curTest->Run();
+
+	int const testTimeInMs = testTimer.GetTimeInMs();
+	if (maxTestTimeInMs > 0 && testTimeInMs > maxTestTimeInMs && !curTest->m_timeConstraintExempt)
+	{
+	    MemoryOutStream stream;
+	    stream << "Global time constraint failed. Expected under " << maxTestTimeInMs <<
+	            "ms but took " << testTimeInMs << "ms.";
+
+	    result->OnTestFailure(curTest->m_details, stream.GetText());
+	}
+
+	result->OnTestFinish(curTest->m_details, testTimeInMs/1000.0f);
+}
+
+}

data/vendor/simdjson/dependencies/sajson/third-party/UnitTest++/src/TestRunner.h

@@ -0,0 +1,61 @@
+#ifndef UNITTEST_TESTRUNNER_H
+#define UNITTEST_TESTRUNNER_H
+
+#include "Test.h"
+#include "TestList.h"
+#include "CurrentTest.h"
+
+namespace UnitTest {
+
+class TestReporter;
+class TestResults;
+class Timer;
+
+int RunAllTests();
+
+struct True
+{
+	bool operator()(const Test* const) const
+	{
+		return true;	
+	}
+};
+
+class TestRunner
+{
+public:
+	explicit TestRunner(TestReporter& reporter);
+	~TestRunner();
+
+	template <class Predicate>
+	int RunTestsIf(TestList const& list, char const* suiteName, 
+				   const Predicate& predicate, int maxTestTimeInMs) const
+	{
+	    Test* curTest = list.GetHead();
+
+	    while (curTest != 0)
+	    {
+		    if (IsTestInSuite(curTest,suiteName) && predicate(curTest))
+			{
+				RunTest(m_result, curTest, maxTestTimeInMs);
+			}
+
+			curTest = curTest->next;
+	    }
+
+	    return Finish();
+	}	
+
+private:
+	TestReporter* m_reporter;
+	TestResults* m_result;
+	Timer* m_timer;
+
+	int Finish() const;
+	bool IsTestInSuite(const Test* const curTest, char const* suiteName) const;
+	void RunTest(TestResults* const result, Test* const curTest, int const maxTestTimeInMs) const;
+};
+
+}
+
+#endif