246 lines
7.1 KiB
C++
246 lines
7.1 KiB
C++
#include <iostream>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <vector>
|
|
#include <fstream>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <map>
|
|
#include <sys/stat.h>
|
|
#include "../UnitTest.h"
|
|
|
|
using namespace std;
|
|
|
|
map<string, string> options;
|
|
vector<string> lines;
|
|
vector<unsigned int> line_numbers;
|
|
size_t counter = 0;
|
|
string make;
|
|
string ArchivedOptions;
|
|
string makeStyle;
|
|
|
|
string makeOptions[] = {
|
|
"single",
|
|
"debug",
|
|
"small"
|
|
};
|
|
|
|
void makeMap(void){
|
|
options["LIBRARY"] = "#define JSON_LIBRARY";
|
|
options["DEBUG"] = "#define JSON_DEBUG";
|
|
options["STREAM"] = "#define JSON_STREAM";
|
|
options["SAFE"] = "#define JSON_SAFE";
|
|
options["STDERROR"] = "#define JSON_STDERROR";
|
|
options["PREPARSE"] = "#define JSON_PREPARSE";
|
|
options["LESS_MEMORY"] = "#define JSON_LESS_MEMORY";
|
|
options["UNICODE"] = "#define JSON_UNICODE";
|
|
options["REF_COUNT"] = "#define JSON_REF_COUNT";
|
|
options["BINARY"] = "#define JSON_BINARY";
|
|
options["MEMORY_CALLBACKS"] = "#define JSON_MEMORY_CALLBACKS";
|
|
options["MEMORY_MANAGE"] = "#define JSON_MEMORY_MANAGE";
|
|
options["MUTEX_CALLBACKS"] = "#define JSON_MUTEX_CALLBACKS";
|
|
options["MUTEX_MANAGE"] = "#define JSON_MUTEX_MANAGE";
|
|
options["ITERATORS"] = "#define JSON_ITERATORS";
|
|
options["WRITER"] = "#define JSON_WRITE_PRIORITY MID";
|
|
options["READER"] = "#define JSON_READ_PRIORITY HIGH";
|
|
options["NEWLINE"] = "#define JSON_NEWLINE \"\\r\\n\"";
|
|
options["COMMENTS"] = "#define JSON_COMMENTS";
|
|
options["INDENT"] = "#define JSON_INDENT \" \"";
|
|
options["WRITE_BASH_COMMENTS"] = "#define JSON_WRITE_BASH_COMMENTS";
|
|
options["WRITE_SINGLE_LINE_COMMENTS"] = "#define JSON_WRITE_SINGLE_LINE_COMMENTS";
|
|
options["VALIDATE"] = "#define JSON_VALIDATE";
|
|
options["UNIT_TEST"] = "#define JSON_UNIT_TEST";
|
|
options["INDEX_TYPE"] = "#define JSON_INDEX_TYPE unsigned int";
|
|
options["CASE_INSENSITIVE_FUNCTIONS"] = "#define JSON_CASE_INSENSITIVE_FUNCTIONS";
|
|
options["ESCAPE_WRITES"] = "#define JSON_ESCAPE_WRITES";
|
|
options["STRINGU_HEADER"] = "#define JSON_STRING_HEADER \"../TestSuite/UStringTest.h\"";
|
|
options["STRING_HEADER"] = "#define JSON_STRING_HEADER \"../TestSuite/StringTest.h\"";
|
|
options["CASTABLE"] = "#define JSON_CASTABLE";
|
|
options["STRICT"] = "#define JSON_STRICT";
|
|
options["MEMORY_POOL"] = "#define JSON_MEMORY_POOL 524288";
|
|
}
|
|
|
|
void testRules(unsigned int i){
|
|
remove("./testapp");
|
|
int q = system(make.c_str());
|
|
bool Archive = false;
|
|
if (FILE * fp = fopen("./testapp", "r")){
|
|
fclose(fp);
|
|
|
|
remove("./out.html");
|
|
q = system("./testapp");
|
|
if (FILE * fp = fopen("./out.html", "r")){
|
|
char buffer[255];
|
|
size_t qq = fread(&buffer[0], 255, 1, fp);
|
|
buffer[254] = '\0';
|
|
fclose(fp);
|
|
string buf(&buffer[0]);
|
|
size_t pos = buf.find("Failed Tests: <c style=\"color:#CC0000\">");
|
|
if (pos == string::npos){
|
|
FAIL("Something Wrong");
|
|
} else {
|
|
if(buf[pos + 39] == '0'){
|
|
PASS("GOOD");
|
|
} else {
|
|
size_t pp = buf.find('<', pos + 39);
|
|
FAIL(string("Didn't pass ") + buf.substr(pos + 39, pp - pos - 39) + " tests");
|
|
ArchivedOptions = std::string("Fail_") + ArchivedOptions;
|
|
Archive = true;
|
|
}
|
|
}
|
|
} else {
|
|
FAIL("Running crashed");
|
|
ArchivedOptions = std::string("Crashed_") + ArchivedOptions;
|
|
Archive = true;
|
|
}
|
|
} else {
|
|
FAIL(string("Compilation failed - ") + lines[i]);
|
|
ArchivedOptions = std::string("Compile_") + ArchivedOptions;
|
|
Archive = true;
|
|
}
|
|
|
|
//If something broke, make a copy of the options used to make the failure, so it can be easily retested
|
|
if (Archive){
|
|
if (FILE * fp = fopen("../JSONOptions.h", "r")){
|
|
ArchivedOptions = std::string("../") + ArchivedOptions;
|
|
if (FILE * ofp = fopen(ArchivedOptions.c_str(), "w")){
|
|
char buffer[2048] = {'\0'};
|
|
size_t qq = fread(&buffer[0], 2048, 1, fp);
|
|
fwrite(&buffer[0], strlen(&buffer[0]), 1, ofp);
|
|
fclose(ofp);
|
|
}
|
|
fclose(fp);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool makeTempOptions(unsigned int i){
|
|
string & line = lines[i];
|
|
|
|
if (FILE * fp = fopen("../JSONOptions.h", "w")){
|
|
string res("#ifndef JSON_OPTIONS_H\n#define JSON_OPTIONS_H\n");
|
|
for (
|
|
map<string, string>::iterator runner = options.begin(), end = options.end();
|
|
runner != end;
|
|
++runner){
|
|
|
|
if (line.find(runner -> first) != string::npos){
|
|
res += runner -> second + "\n";
|
|
}
|
|
}
|
|
res += "#endif\n";
|
|
|
|
fwrite(res.c_str(), res.length(), 1, fp);
|
|
fclose(fp);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool hideGoodOptions(void){
|
|
struct stat stFileInfo;
|
|
if (stat("../__JSONOptions.h", &stFileInfo)){
|
|
remove("../JSONOptions.h");
|
|
return true;
|
|
}
|
|
return (rename("../JSONOptions.h", "../__JSONOptions.h") == 0);
|
|
}
|
|
|
|
bool loadTests(){
|
|
ifstream infile("All/Options.txt");
|
|
|
|
if (!infile){
|
|
return false;
|
|
}
|
|
|
|
string line;
|
|
unsigned int iii = 0;
|
|
while (getline(infile, line)){
|
|
++iii;
|
|
size_t pos = line.find_first_not_of(' ');
|
|
if (pos != string::npos){
|
|
line = line.substr(pos);
|
|
pos = line.find_first_not_of("\r\n\t ");
|
|
if ((line.length() > 5) && (line[0] != '#')){
|
|
const string temp(line.substr(pos));
|
|
lines.push_back(string("READER, ") + temp);
|
|
line_numbers.push_back(iii);
|
|
if ((temp.find("VALIDATE") == string::npos) && (temp.find("STREAM") == string::npos)){
|
|
lines.push_back(temp);
|
|
line_numbers.push_back(iii);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
infile.close();
|
|
return true;
|
|
}
|
|
|
|
void RunTest(const std::string & version, unsigned int i){
|
|
if(makeTempOptions(i)){
|
|
stringstream mystream;
|
|
mystream << version << " Line " << line_numbers[i];
|
|
cout << "Compiling " << ++counter << " of " << line_numbers.size() * 3 << " - " << mystream.str() << endl;
|
|
cout << " " << lines[i] << endl;
|
|
UnitTest::SetPrefix(mystream.str());
|
|
stringstream options_;
|
|
options_ << version << "_Line_" << line_numbers[i] << "_JSONOptions.h";
|
|
ArchivedOptions = options_.str();
|
|
testRules(i);
|
|
remove("../JSONOptions.h");
|
|
UnitTest::SaveTo("progress.html");
|
|
}
|
|
}
|
|
|
|
void Go(const std::string & version, unsigned int test){
|
|
echo(make);
|
|
if (makeStyle.empty() || (makeStyle == version)){
|
|
makeStyle.clear();
|
|
for (unsigned int i = test; i < lines.size(); ++i){
|
|
RunTest(version, i);
|
|
}
|
|
} else {
|
|
echo("skipping");
|
|
}
|
|
}
|
|
|
|
|
|
void RunTests(unsigned int test){
|
|
if (hideGoodOptions()){
|
|
if(loadTests()){
|
|
makeMap();
|
|
for(unsigned int i = 0; i < sizeof(makeOptions); ++i){
|
|
make = "make -j4 " + makeOptions[i];
|
|
Go(makeOptions[i], test);
|
|
}
|
|
} else {
|
|
FAIL("couldn't open options");
|
|
}
|
|
rename("../__JSONOptions.h", "../JSONOptions.h");
|
|
} else {
|
|
FAIL("Couldn't protect JSONOptions");
|
|
}
|
|
}
|
|
|
|
int main (int argc, char * const argv[]) {
|
|
UnitTest::StartTime();
|
|
unsigned int test = 0;
|
|
if (argc == 3){
|
|
test = atoi(argv[2]) - 1;
|
|
counter = test;
|
|
echo("starting on test " << test);
|
|
makeStyle = argv[1];
|
|
echo("starting with make " << makeStyle);
|
|
} else if (argc == 2){
|
|
test = 0;
|
|
counter = test;
|
|
echo("starting on test " << test);
|
|
makeStyle = argv[1];
|
|
echo("starting with make " << makeStyle);
|
|
}
|
|
|
|
RunTests(test);
|
|
|
|
UnitTest::SaveTo("out.html");
|
|
return 0;
|
|
}
|