source: icGREP/icgrep-devel/icgrep/combine/icgrep-test/icgrep-test.cpp @ 5825

Last change on this file since 5825 was 5825, checked in by faldebey, 15 months ago

Update to CoRE testing system

File size: 6.7 KB
Line 
1#include "icgrep-test.h"
2#include "../stringGen.h"
3#include "process.h"
4#include <iostream>
5#include <vector>
6#include <array>
7#include <string>
8#include <fstream>
9#include <stdexcept>
10#include <unistd.h>
11#include <stdio.h>
12#include <stdlib.h>
13#include <sys/types.h>
14#include <sys/wait.h>
15
16
17using namespace std;
18
19
20void IcgrepTest::writeToFile(string content, string dir){
21        ofstream file;
22        file.open(dir, std::ofstream::out | std::ofstream::app);
23        if (!file.is_open()){
24                cerr << "Could not open input file: " << dir << endl;
25                return;
26        }
27        file << content << endl;
28        file.close();
29}
30
31void IcgrepTest::generateStringFile(string re, std::vector<string> flags, re::RE_Syntax syntax,
32                                                                        RegexGen::FileType fTy, string dir){
33
34
35        int lineNum = 0;
36        if (fTy == RegexGen::FileType::SMALL){
37                lineNum = 1;
38        }
39        else if (fTy == RegexGen::FileType::MEDIUM){
40                lineNum = 10;
41        }
42        else {
43                lineNum = 100;
44        }
45        for (int i = 0; i < lineNum; i++){
46                StringGenerator strGen(re, flags, syntax);
47                writeToFile(strGen.generate() + "\n", dir);
48        }
49
50}
51
52void IcgrepTest::copyFile(string src, string dst){
53
54        std::ifstream sFile (src.c_str());
55    std::ofstream dFile(dst.c_str());
56    dFile << sFile.rdbuf();
57    dFile.close();
58    sFile.close();
59}
60
61string IcgrepTest::UniversalizePropertyName(string re){
62        std::string::size_type pos = re.find("\\N{^");
63        while (pos != std::string::npos){
64                re.erase(pos+3, 1);
65                pos = re.find("$}");
66                if (pos != std::string::npos){
67                        re.erase(pos,1);
68                }
69                pos = re.find("\\N{^");
70        }
71        return re;
72}
73
74bool IcgrepTest::hasFlag(string flag, std::vector<string> flags){
75        for (auto f : flags){
76                if (strncmp(f.c_str(), flag.c_str(), flag.size()) == 0){
77                        return true;
78                }
79        }
80        return false;
81}
82
83std::vector<string> IcgrepTest::removeFlag(string flag, std::vector<string> flags){
84        int c = 0;
85        for (auto f : flags){
86                if (f.find(flag) == 0){
87                        flags.erase(flags.begin()+c);
88                        return flags;
89                }
90                c++;
91        }
92        return flags;
93}
94
95template<typename InputIterator1, typename InputIterator2>
96bool
97range_equal(InputIterator1 first1, InputIterator1 last1,
98        InputIterator2 first2, InputIterator2 last2)
99{
100    while(first1 != last1 && first2 != last2)
101    {
102        if(*first1 != *first2) return false;
103        ++first1;
104        ++first2;
105    }
106    return (first1 == last1) && (first2 == last2);
107}
108
109bool IcgrepTest::identicalFiles(const std::string& filename1, const std::string& filename2)
110{
111    std::ifstream file1(filename1);
112    std::ifstream file2(filename2);
113
114    std::istreambuf_iterator<char> begin1(file1);
115    std::istreambuf_iterator<char> begin2(file2);
116
117    std::istreambuf_iterator<char> end;
118    bool identical = range_equal(begin1, end, begin2, end);
119
120    file1.close();
121    file2.close();
122
123    return identical;
124}
125
126void IcgrepTest::reportBug(vector<string> &icgrepArgs, vector<string> &grepArgs, int testNum){
127        cout << "\033[1;31mFAIL\033[0m\n";
128        // ++mBugCount;
129        string bugList = "core-out/bugs/bugList";
130        string bugTestLine = "bug #" + to_string(testNum) + "= ";
131        for (auto arg : icgrepArgs){
132                bugTestLine += arg + " ";
133        }
134        bugTestLine += " === ";
135        for (auto arg : grepArgs){
136                bugTestLine += arg + " ";
137        }
138        bugTestLine += "\n\n";
139        writeToFile(bugTestLine, bugList);
140        string srcReDir = "core-out/reg";
141        string srcStrDir = "core-out/file";
142        string dstReDir = "core-out/bugs/regs/reg" + to_string(testNum);
143        string dstStrDir = "core-out/bugs/files/file" + to_string(testNum);
144        copyFile(srcReDir, dstReDir);
145        copyFile(srcStrDir, dstStrDir);
146
147}
148
149void IcgrepTest::clearTest(){
150        remove("core-out/reg");
151        remove("core-out/file");
152        remove("core-out/icgrep-out");
153        remove("core-out/grep-out");
154}
155
156unsigned IcgrepTest::buildTest(string re, vector<string> flags, re::RE_Syntax syntax, RegexGen::FileType fTy, int testNum){
157
158        clearTest();
159        unsigned errorNo = 0;
160        cout << "==========test: " << testNum << "==========" << endl;
161        cout << "RE: \'" << re << "\'" << endl;
162
163        string reDir = "core-out/reg";
164        string strDir = "core-out/file";
165
166        string icgrepOutputName = "core-out/icgrep-out";
167        string grepOutputName = "core-out/grep-out";
168
169        generateStringFile(re, flags, syntax, fTy, strDir);
170
171        cout << "file generated" << endl;
172        //remove icgrep specific flags and syntax for comparison.
173        vector<string> gflags = removeFlag("-t", flags);
174        gflags = removeFlag("-BlockSize", gflags);
175        gflags = removeFlag("-P", gflags);
176        gflags = removeFlag("-f", gflags);
177        gflags = removeFlag("-e", gflags);
178
179        vector<string> icgrepArgs = {"./icgrep"};
180        vector<string> grepArgs;
181        string baseGrep;
182        bool REfromFile = hasFlag("-f", flags);
183        bool multipleRE = hasFlag("-e", flags);
184        flags = removeFlag("-f", flags);
185        flags = removeFlag("-e", flags);
186
187        for (auto f : flags){
188                icgrepArgs.push_back(f);
189        }
190        if (REfromFile){
191                writeToFile(re, reDir);
192                icgrepArgs.push_back("-f");
193                icgrepArgs.push_back(reDir);
194        }
195        else if (multipleRE){
196                icgrepArgs.push_back("-e");
197                icgrepArgs.push_back(re);
198        }
199        else{
200                icgrepArgs.push_back(re);
201        }
202        icgrepArgs.push_back(strDir);
203
204        if (syntax == re::RE_Syntax::ERE || syntax == re::RE_Syntax::BRE){
205                grepArgs.push_back("grep");
206        }
207        else {
208                grepArgs.push_back("./ugrep");
209                re = UniversalizePropertyName(re);
210        }
211        for (auto f : gflags){
212                grepArgs.push_back(f);
213        }
214        grepArgs.push_back(re);
215        grepArgs.push_back(strDir);
216
217
218        cout << "running " << grepArgs[0] << endl;
219        int r2 = run_test(grepArgs, grepOutputName);
220
221        cout << "running icgrep:\n";
222        int r1 = run_test(icgrepArgs, icgrepOutputName);
223
224
225        cout << "Differential..." << endl;
226
227        if (!r1 && !r2){
228
229                ifstream file;
230                file.open(grepOutputName.c_str());
231                if (!file.is_open()){
232                        cerr << "baseGrep file could not be open." << endl;
233                }
234                string line;
235                if (getline(file, line)){
236                        cout << line << endl;
237                }
238                file.close();
239
240                file.open(icgrepOutputName.c_str());
241                if (!file.is_open()){
242                        cerr << "icgrep file could not be open." << endl;
243                }
244                if (getline(file, line)){
245                        cout << line << endl;
246                }
247                file.close();
248
249                if (identicalFiles(icgrepOutputName, grepOutputName)){
250                        // reportBug(icgrepArgs, grepArgs, testNum);
251                        cout << "\033[1;32mPASS\033[0m\n";
252                }
253                else{
254                        // string line;
255                        file.open(grepOutputName.c_str());
256                        if (!file.is_open()){
257                                cerr << "ugrep file could not be open." << endl;
258                        }
259                        if (getline(file, line)){
260                                if (line.find("U_") ==0)
261                                        cout << "\033[1;34mSKIPPED\033[0m\n";
262                                else{
263                                        errorNo = 1;
264                                        reportBug(icgrepArgs, grepArgs, testNum);
265                                }
266
267                        }
268                        else {
269                                errorNo = 1;
270                                reportBug(icgrepArgs, grepArgs, testNum);
271                        }
272                        file.close();
273                }
274        }
275        else {
276                errorNo = 1;
277                reportBug(icgrepArgs, grepArgs, testNum);
278        }
279
280return errorNo;
281}
282
283// void IcgrepTest::getResult(int testNum){
284//      float bugRate = 100 * (float)(mBugCount) / testNum;
285//      cout << "Number of bugs found: " << to_string(mBugCount) << endl;
286//      cout << "Number of tests performed: " << to_string(testNum) << endl;
287//      cout << "Fail Rate: " << to_string(bugRate) << endl;
288// }
Note: See TracBrowser for help on using the repository browser.