silUnit Source Code

string silResultsDirectory = "_silUnitResults";
 
 
struct stringLow {
    string value;
    string lower;
}
 
struct suiteResults {
    string name;
    number total;
    number passes;
    number failures;
    string resultXML;
}
 
/**
* Sorts an array of strings regardless of casing.
* Normal Sort: A,B,C,a,b,c
*   This Sort: A,a,B,b,C,c
* @param array - The array to sort
* @return The sorted array
*/
function sortAlpha(string[] array) {
    stringLow[] lowerResults;
    for(string a in array) {
        stringLow sl;
        sl.value = a;
        sl.lower = toLower(a);
        lowerResults += sl;
    }
    try { lowerResults = arrayStructSort(lowerResults, "lower"); } catch {}
     
    string[] result;
    for(stringLow sl in lowerResults) { result += sl.value; }
    return result;
}
 
/**
* Lists all the files in a given directory tree. 
* @param dirName - The path of directory to search
* @param excludes - A list of directories or files to exclude from results
* @return The list of files found in the directory
*/
function directoryFiles(string dirName, string[] excludes) {
    string[] dirScripts;
    if(arrayElementExists(excludes, dirName)) { return dirScripts; }
     
    string[] dirs = findDirectories(dirName, ".*");
    dirs = sortAlpha(dirs);
     
    for(string d in dirs) { 
        dirScripts += directoryFiles(d, excludes);
    }
     
    string[] dirFiles;
    for(string df in findFiles(dirName, ".*\\.test.sil")) {
        boolean toAdd = true;
        for(string ex in excludes) {
            if(startsWith(df, ex)) { toAdd = false; break; }
        }
        if(toAdd) { dirFiles += df; }
    }
    dirScripts += sortAlpha(dirFiles);
    return dirScripts;
}
 
/**
* Creates a JUnit style XML tag for passing tests
* @param className - The name of current test file
* @param name - The name of the current test
* @return XML representation
**/
function passText(string className, string name) {
    return "   <testcase classname='"+className+"' name='"+name+"'/>";
}
 
/**
* Creates a JUnit style XML tag for failing tests
* @param className - The name of current test file
* @param name - The name of the current test
* @param type - The 'assert' type that caused the failure
* @param message - The error message printed in the error failure tag
* @return XML representation
**/
function failText(string className, string name, string type, string message) {
    return "   <testcase classname='"+className+"' name='"+name+"'>\n      <failure type='"+type+"'>"+message+"</failure>\n   </testcase>";
}
 
/**
* Creates a struct representing the results of a testcase
* @param name - The name of the testcase
* @param total - The total numbers of tests within the testcase
* @param pass - The number of passed tests within the testcase
* @param fail - The number of failed tests within the testcase
* @param resultXML - The path of the JUnit XML file
* @return The struct representation of the testcase results
**/
function processResult(string name, number total, number pass, number fail, string resultXML) {
    suiteResults result;
    result.name = name;
    result.total = total;
    result.passes = pass;
    result.failures = fail;
    result.resultXML = resultXML;
    return result;
}
 
/**
* Creates a string representation of the testcase results
* @return String of information about testcase
**/
function printResult(suiteResults result) {
    return result.name+" ---> Tests: "+result.total+" (P: "+result.passes+" - F: "+result.failures+")";
}
 
/**
* Retrieves a list functions within provided string, where the function is annoted with a specfic label
* @param testText - String to search for annotations
* @param annotation - Text used to annotate functions. Examples: TEST, BEFORE, AFTER, BEFOREEACH, AFTEREACH
* @return String array of function names containing annotation
**/
function getAnnotatedFunctions(string testText, string annotation) {
    string[] results;
    string regPre = "(?<=(\\/\\*\\*";
    string regPost = "\\*\\*\\/(\n|.)function )).+?(?=\\()";
    string regex = "("+regPre+"(?i)"+annotation+regPost+")|("+regPre+".(?i)"+annotation+"."+regPost+")"; // Creates a complex REGEX looking for variations in silUnit annotations
     
    testText = replace(testText, "\r\n", "\n");
    string current = testText;
     
    // Finds all matched cases
    while(matchEnd(current, regex) != -1) {
        results += matchText(current, regex);
        current = substring(current, matchEnd(current, regex), length(current));
    }
    return results;
}
 
/**
* Parses a provided test file, generates a 'runner' script based on annotations within test file, and executes the tests
* @param path - The path of a test file to evaluate
* @return String representation of test results
**/
function executeTest(string path) {
    // Gets annotationed functions from test file
    string testText = readFromTextFile(path);
    string[] testNames = getAnnotatedFunctions(testText, "TEST");
    string[] before = getAnnotatedFunctions(testText, "BEFORE");
    string[] beforeEach = getAnnotatedFunctions(testText, "BEFOREEACH");
    string[] after = getAnnotatedFunctions(testText, "AFTER");
    string[] afterEach = getAnnotatedFunctions(testText, "AFTEREACH");
 
    // Creates the 'runner' script
    if(!directoryExists(silResultsDirectory)) { createDirectory(silResultsDirectory); }
    string[] pathSplit = split(path, "/");
    string newPath = silResultsDirectory+"/"+pathSplit[size(pathSplit)-1]+"Run.sil";
    if(fileExists(newPath)) { deleteFile(newPath); }
    createFile(newPath);
    path = replace(path, silEnv("sil.home")+"/", "");
     
    printInFile(newPath, "include \""+path+"\";");
    printInFile(newPath, "string directory = \""+silResultsDirectory+"\";");
    printInFile(newPath, "string testResults = directory+\"/"+replace(path, "/", "_")+"Results.xml\";");
    printInFile(newPath, "number testNumbs = "+size(testNames)+";");
    printInFile(newPath, "number passes = 0;");
    printInFile(newPath, "number failures = 0;");
    printInFile(newPath, " ");
    printInFile(newPath, "if(!directoryExists(directory)) { createDirectory(directory); }");
    printInFile(newPath, "if(fileExists(testResults)) { deleteFile(testResults); }");
    printInFile(newPath, "createFile(testResults);");
    printInFile(newPath, "printInFile(testResults, \"<testsuite tests='"+size(testNames)+"'>\");");
    printInFile(newPath, " ");
    for(string b in before) {
        printInFile(newPath, "try { "+b+"(); } catch { logPrint(\"WARN\", \" - "+path+": "+b+"\"); }");
    }
    // Adds each test to the 'runner' script
    for(string t in testNames) {
        printInFile(newPath, "// -----------------------------------------------------------------------------");
        for(string be in beforeEach) { printInFile(newPath, "try { logPrint(\"WARN\", \" - "+path+": "+be+"\"); "+be+"(); } catch { }"); }
        printInFile(newPath, "try { ");
        printInFile(newPath, "    "+t+"();");
        printInFile(newPath, "    logPrint(\"WARN\", \" - "+path+": "+t+"\");");
        printInFile(newPath, "    passes++;");
        printInFile(newPath, "    printInFile(testResults, passText(\""+path+"\", \""+t+"\"));");
        printInFile(newPath, "} catch string err {");
        printInFile(newPath, "    string[] messArr = split(err, \"-\");");
        printInFile(newPath, "    printInFile(testResults, failText(\""+path+"\", \""+t+"\", messArr[0], messArr[1]));");
        printInFile(newPath, "    logPrint(\"ERROR\", \" - "+path+": "+t+"-FAILURE: \"+messArr[0]+\"-\"+messArr[1]); ");
        printInFile(newPath, "    failures++;");
        printInFile(newPath, "}");
        for(string be in afterEach) { printInFile(newPath, "try { logPrint(\"WARN\", \" - "+path+": "+be+"\"); "+be+"(); } catch { }"); }
         
        printInFile(newPath, " ");
    }
    for(string b in after) {
        printInFile(newPath, "try { "+b+"(); } catch { logPrint(\"WARN\", \" - "+path+": "+b+"\"); }");
    }
    printInFile(newPath, "printInFile(testResults, \"</testsuite>\");");
    printInFile(newPath, "return processResult(\""+path+"\", testNumbs, passes, failures, testResults);");
    string resultString = call("", newPath, {});
    // deleteFile(newPath);
    return resultString;
}
 
/**
* Executes a series of testcases within a provided directory. Generates a global XML file containing all test results.
* @param testDirectory - A directory to search for scripts ending in '.test.sil'
**/
function executeSuite(string testDirectory) {
    string outputName = replace(testDirectory, silEnv("sil.home"), "");
    if(outputName == "") { outputName = "silprograms"; }
    string suiteOutputFile = silResultsDirectory+outputName+".xml";
    runnerLog("Result File: "+suiteOutputFile);
    if(fileExists(suiteOutputFile)) { deleteFile(suiteOutputFile); }
    createFile(suiteOutputFile);
    printInFile(suiteOutputFile, "<testsuites>");
     
    string[] files = directoryFiles(testDirectory, {});
    runnerLog(" -- Test Files: "+size(files));
    suiteResults rTotal =  processResult("Total", 0, 0, 0, "");
    for(string f in files) {
        suiteResults r = executeTest(f);
        printInFile(suiteOutputFile, trim(readFromTextFile(r.resultXML)));
        deleteFile(r.resultXML);
        runnerLog(printResult(r));
        rTotal.total += r.total;
        rTotal.passes += r.passes;
        rTotal.failures += r.failures;
        rTotal.resultXML += r.resultXML;
    }
    printInFile(suiteOutputFile, "</testsuites>");
    return rTotal;
}
 
////////////////////////////////////////////////////////////////////////////////
//                                  ASSERTS                                   //
////////////////////////////////////////////////////////////////////////////////
 
function assertEquals(string expected, string result) {
    if(toUpper(expected) != toUpper(result)) {
        string resultString = "assertEquals-'"+result+"' does not equal the expected result '"+expected+"'";
        throw resultString;
    }
}
 
function assertNotEquals(string expected, string result) {
    if(toUpper(expected) == toUpper(result)) {
        string resultString = "assertNotEquals-'"+result+"' does equal the expected result '"+expected+"'";
        throw resultString;
    }
}
 
function assertNull(string result) {
    if(isNotNull(result)) {
        string resultString = "assertNull-'"+result+"' is not null";
        throw resultString;
    }
}
 
function assertNotNull(string result) {
    if(isNull(result)) {
        string resultString = "assertNotNull-Value is null";
        throw resultString;
    }
}
 
function assertTrue(boolean result) {
    if(!result) {
        string resultString = "assertTrue-Value is false";
        throw resultString;
    }
}
 
function assertFalse(boolean result) {
    if(result) {
        string resultString = "assertTrue-Value is true";
        throw resultString;
    }
}
Additional Help

Need help implementing silUnit? Talk to me directly to me by clicking on the bot on this page.