191 lines
6.6 KiB
C++
191 lines
6.6 KiB
C++
/*
|
|
* @file
|
|
* @author TPOC: contact@palisade-crypto.org
|
|
*
|
|
* @copyright Copyright (c) 2019, New Jersey Institute of Technology (NJIT)
|
|
* All rights reserved.
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution. THIS SOFTWARE IS
|
|
* PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
* EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <iostream>
|
|
|
|
#include "include/gtest/gtest.h"
|
|
#include "src/gtest-all.cc"
|
|
|
|
#include "lattice/backend.h"
|
|
#include "lattice/elemparams.h"
|
|
#include "lattice/ildcrtparams.h"
|
|
#include "lattice/ilelement.h"
|
|
#include "lattice/ilparams.h"
|
|
#include "math/backend.h"
|
|
#include "math/distrgen.h"
|
|
#include "math/nbtheory.h"
|
|
#include "utils/inttypes.h"
|
|
#include "utils/utilities.h"
|
|
|
|
using namespace std;
|
|
using namespace lbcrypto;
|
|
using namespace testing;
|
|
|
|
static string lead = "****** ";
|
|
|
|
class MinimalistPrinter : public EmptyTestEventListener {
|
|
public:
|
|
void OnTestProgramStart(const ::testing::UnitTest& unit_test) {
|
|
cout << lead << "PALISADE Version " << GetPALISADEVersion() << endl;
|
|
cout << lead << "Date "
|
|
<< testing::internal::FormatEpochTimeInMillisAsIso8601(
|
|
unit_test.start_timestamp())
|
|
<< endl;
|
|
}
|
|
void OnTestIterationStart(const ::testing::UnitTest& unit_test,
|
|
int iteration) {}
|
|
void OnEnvironmentsSetUpStart(const ::testing::UnitTest& unit_test) {}
|
|
void OnEnvironmentsSetUpEnd(const ::testing::UnitTest& unit_test) {}
|
|
void OnTestCaseStart(const ::testing::TestCase& test_case) {}
|
|
void OnTestStart(const ::testing::TestInfo& test_info) {}
|
|
|
|
// Called after a failed assertion or a SUCCEED() invocation.
|
|
void OnTestPartResult(const ::testing::TestPartResult& test_part_result) {}
|
|
|
|
void OnTestEnd(const ::testing::TestInfo& test_info) {
|
|
if (test_info.result()->Passed()) {
|
|
return;
|
|
}
|
|
|
|
auto tr = test_info.result();
|
|
|
|
for (int i = 0; i < tr->total_part_count(); i++) {
|
|
auto pr = tr->GetTestPartResult(i);
|
|
if (pr.passed()) continue;
|
|
|
|
internal::ColoredPrintf(internal::COLOR_GREEN, "[ RUN ] ");
|
|
printf("%s.%s\n", test_info.test_case_name(), test_info.name());
|
|
fflush(stdout);
|
|
|
|
auto n = pr.file_name();
|
|
if (n != NULL) cout << n << ":" << pr.line_number() << "\n";
|
|
|
|
cout << pr.summary() << endl;
|
|
|
|
internal::ColoredPrintf(internal::COLOR_RED, "[ FAILED ] ");
|
|
printf("%s.%s\n", test_info.test_case_name(), test_info.name());
|
|
fflush(stdout);
|
|
internal::PrintFullTestCommentIfPresent(test_info);
|
|
}
|
|
}
|
|
void OnTestCaseEnd(const ::testing::TestCase& test_case) {}
|
|
void OnEnvironmentsTearDownStart(const ::testing::UnitTest& unit_test) {}
|
|
void OnEnvironmentsTearDownEnd(const ::testing::UnitTest& /*unit_test*/) {}
|
|
void OnTestIterationEnd(const ::testing::UnitTest& unit_test, int iteration) {
|
|
}
|
|
|
|
void OnTestProgramEnd(const ::testing::UnitTest& unit_test) {
|
|
cout << lead << "End " << unit_test.test_to_run_count() << " cases "
|
|
<< unit_test.successful_test_count() << " passed "
|
|
<< unit_test.failed_test_count() << " failed" << endl;
|
|
|
|
const int failed_test_count = unit_test.failed_test_count();
|
|
if (failed_test_count == 0) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
|
|
const TestCase& test_case = *unit_test.GetTestCase(i);
|
|
if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
|
|
continue;
|
|
}
|
|
for (int j = 0; j < test_case.total_test_count(); ++j) {
|
|
const TestInfo& test_info = *test_case.GetTestInfo(j);
|
|
if (!test_info.should_run() || test_info.result()->Passed()) {
|
|
continue;
|
|
}
|
|
internal::ColoredPrintf(internal::COLOR_RED, "[ FAILED ] ");
|
|
printf("%s.%s", test_case.name(), test_info.name());
|
|
internal::PrintFullTestCommentIfPresent(test_info);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
bool TestB2 = false;
|
|
bool TestB4 = false;
|
|
bool TestB6 = false;
|
|
bool TestNative = true;
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
|
|
bool terse = false;
|
|
bool beset = false;
|
|
for (int i = 1; i < argc; i++) {
|
|
if (string(argv[i]) == "-t") {
|
|
terse = true;
|
|
} else if (string(argv[i]) == "-all") {
|
|
TestB2 = TestB4 = TestB6 = true;
|
|
beset = true;
|
|
} else if (string(argv[i]) == "-2") {
|
|
TestB2 = true;
|
|
beset = true;
|
|
} else if (string(argv[i]) == "-4") {
|
|
TestB4 = true;
|
|
beset = true;
|
|
} else if (string(argv[i]) == "-6") {
|
|
TestB6 = true;
|
|
beset = true;
|
|
}
|
|
}
|
|
|
|
// if there are no filters used, default to omitting VERY_LONG tests
|
|
// otherwise we lose control over which tests we can run
|
|
|
|
if (::testing::GTEST_FLAG(filter) == "*") {
|
|
::testing::GTEST_FLAG(filter) = "-*_VERY_LONG";
|
|
}
|
|
|
|
::testing::TestEventListeners& listeners =
|
|
::testing::UnitTest::GetInstance()->listeners();
|
|
|
|
if (!beset) {
|
|
if (MATHBACKEND == 2)
|
|
TestB2 = true;
|
|
else if (MATHBACKEND == 4)
|
|
TestB4 = true;
|
|
else if (MATHBACKEND == 6)
|
|
TestB6 = true;
|
|
}
|
|
|
|
if (terse) {
|
|
// Adds a listener to the end. Google Test takes the ownership.
|
|
delete listeners.Release(listeners.default_result_printer());
|
|
listeners.Append(new MinimalistPrinter);
|
|
} else {
|
|
cout << "PALISADE Version " << GetPALISADEVersion() << endl;
|
|
cout << "Default Backend " << GetMathBackendParameters() << endl;
|
|
}
|
|
|
|
std::cout << "Testing Backends: " << (TestB2 ? "2 " : "")
|
|
<< (TestB4 ? "4 " : "") << (TestB6 ? "6 " : "")
|
|
<< (TestNative ? "Native " : "") << std::endl;
|
|
|
|
return RUN_ALL_TESTS();
|
|
}
|