blob: f4ec6f15f6f7128fb0ce9e68cef2e22c9703e272 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
/*
* Copyright (c) 2010-2017 Isode Limited.
* All rights reserved.
* See the COPYING file for more information.
*/
#include <cstdlib>
#include <fstream>
#include <string>
#include <sstream>
#include <boost/algorithm/string/predicate.hpp>
#include <gtest/gtest.h>
#include <QA/Checker/CppUnitTestResultPrinter.h>
#include <cppunit/BriefTestProgressListener.h>
#include <cppunit/TextOutputter.h>
#include <cppunit/TextTestProgressListener.h>
#include <cppunit/TextTestResult.h>
#include <cppunit/XmlOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
#include <Swiften/Base/Log.h>
using Swift::Log;
int main(int argc, char* argv[]) {
bool verbose = false;
bool outputXML = false;
Log::setLogLevel(Swift::Log::error);
// Parse parameters
std::vector<std::string> testsToRun;
for (int i = 1; i < argc; ++i) {
std::string param(argv[i]);
if (param == "--verbose") {
verbose = true;
}
else if (param == "--xml") {
outputXML = true;
}
else if (param == "--debug") {
Swift::Log::setLogLevel(Swift::Log::debug);
}
else if (boost::starts_with(param, "--")) {
continue;
}
else {
testsToRun.push_back(param);
}
}
if (testsToRun.empty()) {
testsToRun.push_back("");
}
// generate output filenames for XML test output
std::string gtestOutputFilename;
std::string cppunitOutputFilename;
if (outputXML) {
auto programName = std::string(argv[0]);
std::stringstream outFileStringStreamGTest("");
outFileStringStreamGTest << "xml:" << programName << "-report.gtest.xml";
gtestOutputFilename = outFileStringStreamGTest.str();
std::stringstream outFileStringStreamCppUnit("");
outFileStringStreamCppUnit << programName << "-report.cppunit.xml";
cppunitOutputFilename = outFileStringStreamCppUnit.str();
}
if (outputXML && (std::getenv("GTEST_OUTPUT") == nullptr)) {
::testing::GTEST_FLAG(output) = gtestOutputFilename;
}
// Google Test might throw an exception in an anonymous namespace. Exiting
// due to uncaught execption is fine here.
// coverity[fun_call_w_exception]
::testing::InitGoogleTest(&argc, argv);
// Set up the listeners
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener(&result);
CppUnit::TextTestProgressListener progressListener;
CppUnit::BriefTestProgressListener verboseListener;
if (!outputXML) {
if (verbose) {
controller.addListener(&verboseListener);
}
else {
controller.addListener(&progressListener);
}
}
// Run the tests
CppUnit::TestRunner runner;
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
for (std::vector<std::string>::const_iterator i = testsToRun.begin(); i != testsToRun.end(); ++i) {
try {
runner.run(controller, *i);
}
catch (const std::exception& e) {
std::cerr << "Error: " << e.what() << std::endl;
return -1;
}
}
// Output the results
if (outputXML) {
std::ofstream cppUnitXUnitOutputFile;
cppUnitXUnitOutputFile.open(cppunitOutputFilename, std::ofstream::out | std::ofstream::trunc);
if (cppUnitXUnitOutputFile.is_open()) {
CppUnit::XmlOutputter outputter(&result, cppUnitXUnitOutputFile);
outputter.write();
}
else {
std::cerr << "Failed to overwrite " << cppunitOutputFilename << " output file." << std::endl;
return 1;
}
}
else {
CppUnit::TextOutputter outputter(&result, std::cerr);
outputter.write();
}
auto googleTestWasSuccessful = false;
try {
if (!verbose) {
testing::UnitTest& unitTest = *testing::UnitTest::GetInstance();
testing::TestEventListeners& listeners = unitTest.listeners();
delete listeners.Release(listeners.default_result_printer());
listeners.Append(new testing::CppUnitTestResultPrinter);
}
googleTestWasSuccessful = RUN_ALL_TESTS() == 0 ? true : false;
} catch (const ::testing::internal::GoogleTestFailureException& e) {
googleTestWasSuccessful = false;
SWIFT_LOG(error) << "GoogleTestFailureException was thrown: " << e.what() << std::endl;
}
auto cppUnitWasSuccessful = result.wasSuccessful() ? true : false;
return (googleTestWasSuccessful && cppUnitWasSuccessful) ? 0 : 1;
}
|
Swift