495 lines
15 KiB
XML
495 lines
15 KiB
XML
<?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>
|