etc/config/windows/runall.wsf

<?xml version="1.0" ?>
<package>
    <comment>
        Licensed to the Apache Software Foundation (ASF) under one
        or more contributor license agreements.  See the NOTICE file
        distributed with this work for additional information
        regarding copyright ownership.  The ASF licenses this file
        to you under the Apache License, Version 2.0 (the
        "License"); you may not use this file except in compliance
        with the License.  You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

        Unless required by applicable law or agreed to in writing,
        software distributed under the License is distributed on an
        "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
        KIND, either express or implied.  See the License for the
        specific language governing permissions and limitations
        under the License.
    </comment>
    <job id="runexamples" prompt="no">
        <?job error="false" debug="false" ?>
        <runtime>
            <description>
runs examples and checks results.
            </description>
            <named helpstring="The root directory with executables" 
                name="EXEDIR" required="true" type="string"/>
            <named helpstring="The directory with project files of the executables" 
                name="PRJDIR" required="false" type="string"/>
            <named helpstring="The configuration" name="CONFIG" 
                required="true" type="string"/>
            <named helpstring="The root directory with .in and .out files" 
                name="INOUTDIR" required="false" type="string"/>
            <named helpstring="The log file" name="LOGFILE" 
                required="false" type="string"/>
            <named helpstring="The examples extension" name="EXT" 
                required="false" type="string"/>
            <named helpstring="The additional options for exec utility"
                name="RUNFLAGS" required="false" type="string"/>
            <example>
            cscript runall.wsf /EXEDIR:"C:\stdcxx\build\examples" 
            /PRJDIR:"C:\stdcxx\build\projects\examples"
            /INOUTDIR:"C:\stdcxx\examples" /CONFIG:msvc-7.1
            </example>
            <usage>
Usage: cscript runexamples.wsf /EXEDIR:@EXEDIR /CONFIG:@CONFIG
[/PRJDIR:@PRJDIR] [/INOUTDIR:@INOUTDIR] [/LOGFILE:@LOGFILE]
[/EXT:@EXT] [/RUNFLAGS:@RUNFLAGS]
where
@EXEDIR is the root directory with executables to be run and checked,
@PRJDIR is the directory with .vcproj files of the executables,
@INOUTDIR is the root directory with .in and .out files ,
required by executables,
@CONFIG is the compiler configuration (msvc-7.1, icc-9.0, etc),
@LOGFILE is the log file name,
@EXT is the extension of the example files, default value: "exe".
@RUNFLAGS is the additional options for exec utility
            </usage>
        </runtime>
        <object id="fso" progid="Scripting.FileSystemObject"/>
        <object id="WshShell" progid="WScript.Shell"/>
        <script language="JScript" src="config.js"/>
        <script language="JScript" src="utilities.js"/>
        <script language="JScript" src="summary.js"/>
        <script id="runexamples" language="JScript">
<![CDATA[
//
// Examples running script for stdcxx library
//

var examplesDir = ""; // path to the root directory containing executables
var projectsDir = ""; // path to the directory containing projects of the executables
var inoutDir = "";    // path to the root directory 
                      // containing the .in and .out files
var currentCfg = "msvc-7.1" // the configuration
var logFileName = ""; // the log file name
var logFileDefault = "runexamples.log"; // the default log file name
var ext = "exe";
var runflags = "";

var varOut = "out";

var exRun = 0;
var exRunSucceeded = 0;
var exRunFailed = 0;
var exRunTimedOut = 0;
var exBadCode = 0;
var exNotCompiled = 0;

var buildlogFile = "BuildLog.htm";
var summaryFileName = "Summary.htm";
var htmFolderName = "temphtm";

var utlExec = "exec.exe";
var unicodeLog = false;
    
var description = new runexamples; // run

// the main function of the script
function runexamples()
{
    readAndCheckArguments();
    
    getCompilerOpts(currentCfg);

    unicodeLog = UNICODELOG;

    var buildOutDir = examplesDir;
    if (! fso.FolderExists(buildOutDir))
        fso.CreateFolder(buildOutDir);
        
    var fLog = fso.CreateTextFile(examplesDir + "\\" + logFileName);
    var fSummary = fso.CreateTextFile(buildOutDir + "\\" + summaryFileName);
    
    runAllExamples(examplesDir, projectsDir, inoutDir, fLog, fSummary, ext);

    var logMsg = "Total run " + exRun + "; " + exRunSucceeded + " succeeded, " +
        exRunFailed + " failed, " + exRunTimedOut + " failed because of timeout, " +
        exBadCode + " exited with non-zero code, " +
        exNotCompiled + " has not compiled";
    
    WScript.Echo(logMsg);
        
    fLog.WriteLine(logMsg);
        
    fLog.Close();
    fSummary.Close();
    
    WScript.Quit(0);
}

// performs checking of the script parameters
function readAndCheckArguments()
{
    if (!WScript.Arguments.Named.Exists("EXEDIR"))
    {
        WScript.StdErr.WriteLine(
            "Generate: Missing required argument EXEDIR.");
        WScript.Arguments.ShowUsage();
        WScript.Quit(2);
    }
    
    if (!WScript.Arguments.Named.Exists("CONFIG"))
    {
        WScript.StdErr.WriteLine(
            "Generate: Missing required argument CONFIG.");
        WScript.Arguments.ShowUsage();
        WScript.Quit(2);
    }
    
    examplesDir =  WScript.Arguments.Named("EXEDIR");
    currentCfg = WScript.Arguments.Named("CONFIG");

    if (WScript.Arguments.Named.Exists("PRJDIR"))
        projectsDir =  WScript.Arguments.Named("PRJDIR");

    if (WScript.Arguments.Named.Exists("INOUTDIR"))
        inoutDir =  WScript.Arguments.Named("INOUTDIR");

    if (WScript.Arguments.Named.Exists("LOGFILE"))
        logFileName = WScript.Arguments.Named("LOGFILE");
    else
        logFileName = logFileDefault;
        
    if (WScript.Arguments.Named.Exists("EXT"))
        ext = WScript.Arguments.Named("EXT");
    
    if (WScript.Arguments.Named.Exists("RUNFLAGS"))
    {
        runflags = WScript.Arguments.Named("RUNFLAGS");
        runflags = runflags.replace(/\'/g, "\"");
    }

    if (! fso.FolderExists(examplesDir))
    {
        WScript.StdErr.WriteLine(
            "Generate: Could not find directory " + examplesDir);
            
        WScript.Quit(3);
    }
    
    if (0 < inoutDir.length && !fso.FolderExists(inoutDir))
    {
        WScript.StdErr.WriteLine(
            "Generate: Could not find directory " + inoutDir);
            
        WScript.Quit(3);
    }
}

// run all executables starting from exeDir
// exeDir - folder containing the executables
// prjDir - folder with .vcproj files of the executables
// srcDir - starting folder to search .in and .out files for the executable
// fileLog - filename of the logfile
// fileSimmary - filename of the summary file
function runAllExamples(exeDir, prjDir, srcDir, fileLog, fileSummary, exeExt)
{
    if (!fso.FolderExists(exeDir))
        return;

    if (0 < prjDir.length && !fso.FolderExists(prjDir))
        return;
    
    var enumFolder = fso.GetFolder(0 < prjDir.length ? prjDir : exeDir);
    
    var htmDir = exeDir + "\\" + htmFolderName;
    if (! fso.FolderExists(htmDir))
        fso.CreateFolder(htmDir);

    var exeFiles = new Array();
    var arrInfo = new Array();
    
    var enumFiles = new Enumerator(enumFolder.Files);
    for (; !enumFiles.atEnd(); enumFiles.moveNext())
    {
        var fileName = enumFiles.item().Name;

        if (0 < prjDir.length)
        {
            // skip "stdcxx_..." projects
            if (0 == fileName.indexOf("stdcxx_") ||
                "vcproj" != fso.GetExtensionName(fileName))
            {
                continue;
            }
        }
        else if (exeExt != fso.GetExtensionName(fileName))
            continue;

        var pureFileName = fso.GetBaseName(fileName);
        var exeFileName = pureFileName + "." + exeExt;
            
        var itemInfo = new ItemBuildInfo(pureFileName);
        readBuildLog(exeDir, itemInfo, unicodeLog);

        itemInfo.runReqOutput = readOutFile(srcDir, exeFileName);

        exeFiles.push(exeFileName);
        arrInfo.push(itemInfo);
        
        ++exRun;
    }
    
    var runCmd = utlExec;
    
    if (0 < srcDir.length)
        runCmd += " -d \"" + srcDir + "\"";

    if (0 < runflags.length)
        runCmd += " " + runflags + " ";

    var targets = exeFiles.join(" ");
    var target_list = null;
    
    var prevDir = WshShell.CurrentDirectory;
    WshShell.CurrentDirectory = exeDir;
    
    // the max command line len == 2047 for Win2000
    // http://support.microsoft.com/kb/830473
    var MaxCmdLineLen = 2047;
    if (MaxCmdLineLen >= runCmd.length + targets.length)
        runCmd += exeFiles.join(" ");
    else
    {
        target_list = "targets.lst";
        
        var strm = fso.CreateTextFile(target_list, true);
        for (var i = 0; i < exeFiles.length; ++i)
            strm.WriteLine(exeFiles[i]);
        strm.Close();
        
        runCmd += "@" + target_list;
    }

    try
    {
        runCmd = "cmd /c " + runCmd + " 2>&1";
        var oExec = WshShell.Exec(runCmd);

        var execOut = "";
        while (oExec.Status == 0)
        {
            execOut += oExec.StdOut.ReadAll();
            WScript.Sleep(100);
        }

        execOut += oExec.StdOut.ReadAll();
        WScript.Echo(execOut);
    }
    catch (e)
    {
        WScript.Echo("Exception in WshShell.Exec(" + runCmd + "): " + e.message);
        return;
    }
    finally
    {
        if (null != target_list)
            fso.DeleteFile(target_list);

        WshShell.CurrentDirectory = prevDir;
    }

    for (var i = 0; i < arrInfo.length; ++i)
    {
        var itemInfo = arrInfo[i];
        
        var outFileName = exeDir + "\\" + itemInfo.name + ".out";

        if (fso.FileExists(outFileName))
        {
            try
            {   
                var outFile = fso.OpenTextFile(outFileName, 1);
                if (!outFile.AtEndOfStream)
                    itemInfo.runOutput = outFile.ReadAll();
                
                outFile.Close();
                fso.DeleteFile(outFileName);
            }
            catch(e)
            {
                WScript.Echo("Could not delete temporary file " + outFileName);
            }
        }
        
        itemInfo.exitCode = parseStatus(itemInfo.name + "." + exeExt, execOut);
        switch (itemInfo.exitCode)
        {
        case  0: // OK
        case -7: // OUTPUT
        case -8: // FORMAT
        case -9: // NOUT
            ++exRunSucceeded;
            fileLog.WriteLine(itemInfo.name + " completed successfully, exit code " +
                itemInfo.exitCode);
            break;
        case -1:  // other
        case -4:  // SEGV
        case -10: // TRAP
            ++exRunFailed;
            fileLog.WriteLine(itemInfo.name + " failed");
            break;
        case -2: // KILLED
            ++exRunTimedOut;
            fileLog.WriteLine(itemInfo.name + " timed out");
            break;
        case -3: // DIFF
            fileLog.WriteLine(itemInfo.name + " completed successfully, " +
                "but output differs from the expected");
            getDifferencesInfo(itemInfo);
            ++exRunFailed;
            break;
        case -5: // COMP
        case -6: // LINK
            fileLog.WriteLine(itemInfo.name + " has not compiled");
            ++exNotCompiled;
            break;
        default:
            ++exBadCode;
            fileLog.WriteLine(itemInfo.name + " completed successfully, exit code " +
                itemInfo.exitCode);
        }

        saveBuildInfo(itemInfo, htmDir, "htm"); 
        saveBuildSummary(itemInfo, fileSummary);
    }
}

// parse the exec utility output to get status of the running executable 
// exename - filename of the executable
// exeOut - stdout content of the exec utility
function parseStatus(exeName, execOut)
{
    var res = 0;

    // maxNameLen is the width of the "NAME" column in the exec utility output
    var maxNameLen = 30;
    var pos = execOut.indexOf(exeName.substr(0, maxNameLen));
    if (0 <= pos)
    {
        pos += maxNameLen + 1;
        var status = execOut.substring(pos, execOut.indexOf(" ", pos + 6));
        res = parseInt(status);
        if (isNaN(res))
        {
            switch (status)
            {
            case "KILLED":
                res = -2;
                break;
            case "  DIFF":
                res = -3;
                break;
            case "  SEGV":
                res = -4;
                break;
            case "  COMP":
                res = -5;
                break;
            case "  LINK":
                res = -6;
                break;
            case "OUTPUT":
                res = -7;
                break;
            case "FORMAT":
                res = -8;
                break;
            case "  NOUT":
                res = -9;
                break;
            case "  TRAP":
                res = -10;
                break;
            default:
                res = -1;
            }
        }
    }

    return res;
}

// returns the content of the .in or .out file for the specified executable
// srcDir - folder containing subfolders with .in and .out files
// exeFileName - filename of the executable
// nameSuffix - one of varIn, varOut
function readAllFromFile(srcDir, exeFileName, nameSuffix)
{   
    if (! fso.FolderExists(srcDir))
        return "";
        
    var pureName = fso.GetBaseName(exeFileName);
        
    var someDir = srcDir + "\\" + nameSuffix;
    if (! fso.FolderExists(someDir))
        return "";
        
    var someFileName = someDir + "\\" + pureName + "." + nameSuffix;
    if (! fso.FileExists(someFileName))
        return "";
        
    var someFile = fso.OpenTextFile(someFileName);
    if (! someFile)
        return "";
        
    return (someFile.ReadAll());
}

// returns the content of the .out file for the specified executable
// srcDir - folder containing .out files
// exeFileName - filename of the executable
function readOutFile(srcDir, exeFileName)
{
    var outData = readAllFromFile(srcDir, exeFileName, varOut);
    
    if (0 == outData.length)
    {
        outData = readAllFromFile(srcDir + "\\manual", exeFileName, varOut);
        if (0 < outData.length)
            srcDir += "\\manual";
        else
        {
            outData = readAllFromFile(srcDir + "\\tutorial", exeFileName, varOut);
            if (0 < outData.length)
                srcDir += "\\tutorial";
        }
    }
    
    var eolStr = String.fromCharCode(13) + String.fromCharCode(10);
    var idxEOL = outData.indexOf(eolStr);
    var outBegin = (idxEOL != -1) ? outData.substr(0, idxEOL) : outData;
    var rgWords = outBegin.split(" ");
    if (rgWords[0] != "link")
        return outData;
    
    // try to open file using the link
    var linkedFileName = srcDir + "\\" + varOut + "\\" + rgWords[1];
    if (! fso.FileExists(linkedFileName))
        return outData;
            
    var linkedFile = fso.OpenTextFile(linkedFileName);
    if (! linkedFile)
        return "";
            
    return (linkedFile.ReadAll());
}

]]>
        </script>
    </job>
</package>