Ignore:
Timestamp:
Jan 10, 2018, 11:06:11 PM (14 months ago)
Author:
faldebey
Message:

Update to CoRE testing system

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/combine/icgrep-test/icgrep-test.cpp

    r5620 r5825  
    11#include "icgrep-test.h"
    22#include "../stringGen.h"
     3#include "process.h"
    34#include <iostream>
    45#include <vector>
     6#include <array>
    57#include <string>
    6 #include <algorithm>
    78#include <fstream>
    8 #include <boost/filesystem.hpp>
    9 #include <boost/iostreams/device/mapped_file.hpp>
    10 #include <boost/algorithm/string/replace.hpp>
     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>
    1115
    1216
    1317using namespace std;
    14 namespace io = boost::iostreams;
    15 namespace fs=boost::filesystem;
    16 
    17 IcgrepTest::IcgrepTest(){}
    18 
    19 std::size_t directorySize(fs::path path)
    20 {
    21         return std::count_if(fs::directory_iterator(path),
    22                          fs::directory_iterator(),
    23                          [](const fs::directory_entry& e) {
    24                           return true;  });
    25 }
    26 
    27 void IcgrepTest::backup(){
    28         int count = directorySize("../icgrep/combine/Archive");
    29 
    30         fs::path src("../icgrep/combine/icgrep-test");
    31         fs::path dst("../icgrep/combine/Archive/test" + to_string(count+1));
    32         if (!fs::create_directory(dst))
    33     {
    34         throw std::runtime_error("Cannot create destination directory " + dst.string());
    35     }
    36 
    37         for (const auto& dirEnt : fs::recursive_directory_iterator{src})
    38     {
    39         const auto& path = dirEnt.path();
    40         auto relativePathStr = path.string();
    41         boost::replace_first(relativePathStr, src.string(), "");
    42         fs::copy(path, dst / relativePathStr);
    43     }
    44 }
    45 void IcgrepTest::resetBash(string fileName){
     18
     19
     20void IcgrepTest::writeToFile(string content, string dir){
    4621        ofstream file;
    47         file.open(fileName);
    48         file << "#!/bin/bash\n\n";
    49         file << "echo \"Starting bash file: " << fileName << "\"\n";
    50         file.close();
    51         //give permission.
    52         string cmd = "chmod +x " + fileName;
    53         system(cmd.c_str());
    54 }
    55 
    56 void IcgrepTest::clearDir(string dir){
    57         fs::path path_to_remove(dir);
    58         for (fs::directory_iterator end_dir_it, it(path_to_remove); it!=end_dir_it; ++it) {
    59                 fs::remove_all(it->path());
    60         }
    61 }
    62 void IcgrepTest::writeToBash(string fileName, string value){
    63         ofstream file;
    64         file.open(fileName, ios::app);
    65         file << value << endl;
    66         file.close();
    67 }
    68 void IcgrepTest::writetoFile(string content, string dir, int fileNo){
    69         string fileName = dir + to_string(fileNo);
    70         ofstream file;
    71         file.open(fileName);
     22        file.open(dir, std::ofstream::out | std::ofstream::app);
    7223        if (!file.is_open()){
    73                 cerr << "Could not open input file\n";
     24                cerr << "Could not open input file: " << dir << endl;
     25                return;
    7426        }
    7527        file << content << endl;
     
    7729}
    7830
    79 void IcgrepTest::prepare(){
    80         backup();
    81         clearDir("../icgrep/combine/icgrep-test/regs");
    82         clearDir("../icgrep/combine/icgrep-test/files");
    83         resetBash("../icgrep/combine/icgrep-test/grep/icgrep-bash.sh");
    84         resetBash("../icgrep/combine/icgrep-test/grep/grep-bash.sh");
    85         resetBash("../icgrep/combine/icgrep-test/ugrep/icgrep-bash.sh");
    86         resetBash("../icgrep/combine/icgrep-test/ugrep/ugrep-bash.sh");
    87         remove("..//icgrep/combine/icgrep-test/grep/icgrep-result");
    88         remove("..//icgrep/combine/icgrep-test/grep/grep-result");
    89         remove("..//icgrep/combine/icgrep-test/ugrep/icgrep-result");
    90         remove("..//icgrep/combine/icgrep-test/ugrep/ugrep-result");
     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;
    9172}
    9273
     
    10384        int c = 0;
    10485        for (auto f : flags){
    105                 if (strncmp(f.c_str(), flag.c_str(), flag.size()) == 0){
     86                if (f.find(flag) == 0){
    10687                        flags.erase(flags.begin()+c);
     88                        return flags;
    10789                }
    10890                c++;
     
    11193}
    11294
    113 void IcgrepTest::buildTest(string re, vector<string> flags, re::RE_Syntax syntax, int testNum){
    114         cout << "test: " << testNum << endl;
     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;
    115161        cout << "RE: \'" << re << "\'" << endl;
    116162
    117         string reDir = "../icgrep/combine/icgrep-test/regs/reg";
    118         string strDir = "../icgrep/combine/icgrep-test/files/file";
    119 
    120         StringGenerator strGen;
    121         writetoFile(strGen.generate(re, flags, syntax) + "\n", strDir, testNum);
    122         //remove icgrep specific flags for comparison.
     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.
    123173        vector<string> gflags = removeFlag("-t", flags);
    124174        gflags = removeFlag("-BlockSize", gflags);
     
    127177        gflags = removeFlag("-e", gflags);
    128178
    129         if (syntax == re::RE_Syntax::ERE){
    130                 string icgrepScript = "../icgrep/combine/icgrep-test/grep/icgrep-bash.sh";
    131                 string grepScript = "../icgrep/combine/icgrep-test/grep/grep-bash.sh";
    132                 string icgrepResult = "../icgrep/combine/icgrep-test/grep/icgrep-result";
    133                 string grepResult = "../icgrep/combine/icgrep-test/grep/grep-result";
    134 
    135                 writeToBash(icgrepScript, "echo \"" + re + "\" | tee -a " + icgrepResult);
    136                 writeToBash(grepScript, "echo \"" + re + "\" | tee -a " + grepResult);
    137 
    138                 if (hasFlag("-f", flags)){
    139                         flags = removeFlag("-f", flags);
    140                         flags = removeFlag("-e", flags);
    141                        
    142                         writetoFile(re, reDir, testNum);
    143                
    144                         writeToBash(icgrepScript,
    145                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " -f " + reDir + to_string(testNum)+
    146                                  " " + strDir + to_string(testNum) + " >> " + icgrepResult + "\n");     
    147                 }
    148                 else if (hasFlag("-e", flags)){
    149                         flags = removeFlag("-f", flags);
    150                         flags = removeFlag("-e", flags);
    151 
    152                         writeToBash(icgrepScript,
    153                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " -e \'" + re + "\' " +
    154                                 " " + strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    155                 }
    156                 else{
    157                         writeToBash(icgrepScript,
    158                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " \'" + re + "\' " +
    159                                 " " + strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    160                 }
    161 
    162                 writeToBash(grepScript,
    163                         "grep " + strGen.stringifyVec(gflags, " ") + " \'" + re + "\' " +
    164                         " " + strDir + to_string(testNum) + " >> " + grepResult + "\n");
    165         }
    166         else if (syntax == re::RE_Syntax::BRE){
    167 
    168                 string icgrepScript = "../icgrep/combine/icgrep-test/grep/icgrep-bash.sh";
    169                 string grepScript = "../icgrep/combine/icgrep-test/grep/grep-bash.sh";
    170                 string icgrepResult = "../icgrep/combine/icgrep-test/grep/icgrep-result";
    171                 string grepResult = "../icgrep/combine/icgrep-test/grep/grep-result";
    172 
    173                 writeToBash(icgrepScript, "echo \"" + re + "\" | tee -a " + icgrepResult);
    174                 writeToBash(grepScript, "echo \"" + re + "\" | tee -a " + grepResult);
    175 
    176                 if (hasFlag("-f", flags)){
    177                         flags = removeFlag("-f", flags);
    178                         flags = removeFlag("-e", flags);
    179 
    180                         writetoFile(re, reDir, testNum);
    181                         writeToBash(icgrepScript,
    182                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " -f " + reDir + to_string(testNum) +
    183                                 " " + strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    184 
    185                 }
    186                 else if (hasFlag("-e", flags)){
    187                         flags = removeFlag("-f", flags);
    188                         flags = removeFlag("-e", flags);
    189                        
    190                         writeToBash(icgrepScript,
    191                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " -e \'" + re + "\' " +
    192                                 strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    193                 }
    194                 else{
    195                         writeToBash(icgrepScript,
    196                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " \'" + re + "\' " +
    197                                 strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    198                 }
    199 
    200                 writeToBash(grepScript,
    201                         "grep " + strGen.stringifyVec(gflags, " ") + " \'" + re + "\' " +
    202                         strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
     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");
    203206        }
    204207        else {
    205                 gflags = removeFlag("-c", gflags);
    206 
    207                 string icgrepScript = "../icgrep/combine/icgrep-test/ugrep/icgrep-bash.sh";
    208                 string ugrepScript = "../icgrep/combine/icgrep-test/ugrep/ugrep-bash.sh";
    209                 string icgrepResult = "../icgrep/combine/icgrep-test/ugrep/icgrep-result";
    210                 string ugrepResult = "../icgrep/combine/icgrep-test/ugrep/ugrep-result";
    211 
    212                 writeToBash(icgrepScript, "echo \"" + re + "\" | tee -a " + icgrepResult);
    213                 writeToBash(ugrepScript, "echo \"" + re + "\" | tee -a " + ugrepResult);
    214 
    215                 if (hasFlag("-f", flags)){
    216                         flags = removeFlag("-f", flags);
    217                         flags = removeFlag("-e", flags);
    218          
    219                         writetoFile(re, reDir, testNum);
    220                         writeToBash(icgrepScript,
    221                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " -f " + reDir + to_string(testNum) +
    222                                 " " + strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    223                 }
    224                 else if (hasFlag("-e", flags)){
    225                         flags = removeFlag("-f", flags);
    226                         flags = removeFlag("-e", flags);
    227 
    228                         writeToBash(icgrepScript,
    229                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " -e \'" + re + "\' " +
    230                                 strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    231                 }
    232                 else{
    233                         writeToBash(icgrepScript,
    234                                 "./icgrep " + strGen.stringifyVec(flags, " ") + " \'" + re + "\' " +
    235                                 strDir + to_string(testNum) + " >> " + icgrepResult + "\n");
    236 
    237                 }
    238 
    239                 writeToBash(ugrepScript,
    240                         "./ugrep " + strGen.stringifyVec(gflags, " ") + " \'" + re + "\' " +
    241                         strDir + to_string(testNum) + " >> " + ugrepResult + "\n");
    242 
    243         }
    244 }
    245 
    246 void IcgrepTest::execute(){
    247         system("../icgrep/combine/icgrep-test/grep/icgrep-bash.sh");
    248         system("../icgrep/combine/icgrep-test/grep/grep-bash.sh");
    249         system("../icgrep/combine/icgrep-test/ugrep/icgrep-bash.sh");
    250         system("../icgrep/combine/icgrep-test/ugrep/ugrep-bash.sh");
    251 }
    252 
    253 void compareResults(string dir1, string dir2, string testName){
    254         io::mapped_file_source f1(dir1);
    255     io::mapped_file_source f2(dir2);
    256 
    257     if(    f1.size() == f2.size()
    258         && std::equal(f1.data(), f1.data() + f1.size(), f2.data())
    259        )
    260         std::cout << testName << "test suceeded!\n";
    261     else
    262         std::cout << testName << "test FAILED!\n";
    263 }
    264 
    265 void IcgrepTest::getResult(){
    266 
    267         compareResults("../icgrep/combine/icgrep-test/grep/icgrep-result", "../icgrep/combine/icgrep-test/grep/grep-result", "GNU grep");
    268     compareResults("../icgrep/combine/icgrep-test/ugrep/icgrep-result", "../icgrep/combine/icgrep-test/ugrep/ugrep-result", "ICU grep");
    269 
    270     cout << "End of test\n";
    271 }
    272 
     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 TracChangeset for help on using the changeset viewer.