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.
One Appfire Support Knowledge Base

silUnit Source Code

Additional Help

Related articles

Filter by label
