def CompareResult(fullName, outputFile, resFile, interpreter, structTest=true):
report.Progress(
4, "Comparing result for " + ` fullName ` + " using diff method")
# compare the results using normal "diff"
actualResult = util.ReadFile(outputFile)
expectedResult = util.ReadFile(resFile)
# Remove duplicate white spaces and line breaks, spaces around commas and parenthesis.
actualResult = string.strip(re.sub("\s+", " ", actualResult))
expectedResult = string.strip(re.sub("\s+", " ", expectedResult))
actualResult = string.strip(re.sub("\s*,\s*", ",", actualResult))
expectedResult = string.strip(re.sub("\s*,\s*", ",", expectedResult))
actualResult = string.strip(re.sub("\s*\(\s*", "(", actualResult))
expectedResult = string.strip(re.sub("\s*\(\s*", "(", expectedResult))
actualResult = string.strip(re.sub("\s*\)\s*", ")", actualResult))
expectedResult = string.strip(re.sub("\s*\)\s*", ")", expectedResult))
if actualResult == expectedResult:
return true
# Hmmm we need to try to compare using VDMDE then.
if structTest and interpreter != None:
report.Progress(
4, "Comparing result for " + ` fullName ` + " by build VDM value")
# template = util.ReadFile(setup.BaseDir+"/../pogtestcases/compare-pog.vdm")
template = util.ReadFile(setup.BaseDir + "/templates/compare-pog.vdm")
if template == None:
return false
data = util.SubString('<<EXPECTED_RESULT>>', expectedResult, template)
data = util.SubString('<<ACTUAL_RESULT>>', actualResult, data)
ok = util.WriteFile("compare.vdm", data)
if not ok:
return false
ok = util.WriteFile(".vdmtest", "compare.arg")
# util.CopyFile(setup.BaseDir+"/../pogtestcases/compare-pog.arg","compare.arg")
# util.CopyFile(setup.BaseDir+"/general-files/compare.arg","compare.arg")
util.CopyFile(setup.BaseDir + "/general-files/compare-pog.arg",
"compare.arg")
# cmd = interpreter + " -a -b compare.vdm"
cmd = interpreter + " -i compare.arg compare.vdm"
(exitcode, dummy1, dummy2) = util.RunCommand(cmd)
ok = (exitcode == 0)
else:
ok = false
if not ok:
report.Error(
"Actual result is different from expected result for " +
` fullName `, "expected result : " + expectedResult + "\n" +
"actual result : " + actualResult)
if util.CleanFile(ok):
util.DeleteFiles(["comapre.arg"])
return ok
def PrintCmdOutput(stdoutFile, stderrFile):
if (cmdline.LookUp('debug-level') >= 5
or cmdline.LookUp('debug-level') == -1):
if os.path.exists(stdoutFile):
data = util.ReadFile(stdoutFile)
if data:
print "[07m[34m" + data + "[30m[0m"
if os.path.exists(stderrFile):
data = util.ReadFile(stderrFile)
if data:
print "[07m[31m" + data + "[30m[0m"
def CompareRunTimeError(resFile):
report.Progress(4, "Searching for runtime error")
actualResult = util.ReadFile(resFile)
if actualResult == None:
return None
if actualResult.find("Run-Time Error") != -1:
expectedResult = util.ReadFile(resFile)
actualResult = re.sub("\s+", " ", actualResult).strip()
expectedResult = re.sub("Run-Time Error[ 0-9]*:", "Run-Time Error ",
expectedResult)
expectedResult = re.sub("\s+", " ", expectedResult).strip()
return actualResult == expectedResult
else:
return None
def RunImplTestCase(fullName, lang, posdef):
ok = convert.ConvertLanguage(lang, fullName)
# Remove the files we expect output in to
if ok:
util.RemoveTestFiles(fullName, [".arg.res"])
# Run the test
if ok:
interpreter = cmdline.LookUpWildCard('tc', lang, 'impl', 'interpreter',
posdef)
if posdef == 'pos':
defFlg = ""
else:
defFlg = " -d "
localName = util.ExtractName(fullName) + ".vdm"
resName = util.ExtractName(fullName) + ".arg.res"
cmd = interpreter + defFlg + " -t -f " + localName + " 2>" + resName
# Now run the interpreter
(exitCode, stdout, stderr) = util.RunCommand(cmd, None, None, true,
true)
# Ensure that the interpreter actually did type check anything.
# That is in contract to if it stoped due to a syntax error or a core dump.
# if re.search("Type checking [^\n]* done", stdout) == None:
# report.Error("text 'type check ... done' not found on stdout while running the type checker",
# "This might be due to a core dump, a syntax error or the like\n" +
# "This does anyway indicate that the type checking was never done",
# stdout, stderr)
# ok = false
if ok:
expResName = resfile.FindResFile(fullName)
# read the result from the result file, and translate it to a list of numbers
# result = TranslateResultImpl(stdout)
result = TranslateResultImpl(util.ReadFile(resName))
if result == None:
ok = false
if ok:
if expResName == None:
print("Not validating result (2)")
if util.KeepFile(false):
WriteResult(fullName, result)
ok = false
if ok:
# Validate the result.
report.Progress(
4, "Validating result with result file: '" + expResName + "'")
ok = ValidateResult(fullName, expResName, result, stdout, stderr)
if util.KeepFile(ok):
WriteResult(fullName, result)
return ok
def CreateDebugFile(fileName, templateName, extra):
base = util.ExtractName(fileName)
astFile = base + ".ast"
debugFile = base + ".debug"
report.Progress(4, "Creating debug (" + debugFile +")")
ast = util.ReadFile(astFile)
if ast == None:
return false
template = util.GetTemplate(templateName)
if template == None:
return false
data = util.SubString("<<AST>>", ast, template)
for key in extra.keys():
data = util.SubString(key, extra[key], data)
ok = util.WriteFile(debugFile, data)
if not ok:
return false
# Make a symlink from the debug file til debug.arg
ok = util.SymLink(debugFile, "debug.arg")
return ok
def ExtractArgFileInfo(fullName):
global modcls
argFile = util.StripExt(fullName)+".arg"
if os.path.exists(argFile):
str = util.ReadFile(argFile)
if str == None:
return None
match = re.match("^ *(.+)`(.+)\(\) *$", str, re.M)
if match == None:
match = re.match("^ *(.+)\.(.+)\(\) *$", str, re.M)
if match == None:
report.Error("Could parse argument file '" + argFile + "' with syntax MOD`OP()")
return None
else:
modcls = match.group(1)
op = match.group(2)
return (None, (modcls, op))
else:
modcls = match.group(1)
op = match.group(2)
else:
modcls = "A"
op = "Test"
return (modcls, op)
def StripSemValue(fullName, lang, dtc):
interpreter = cmdline.LookUpWildCard('pog', lang, 'spec', 'sem-backend')
inNm = util.ExtractName(fullName) + ".arg.res"
outNm = util.ExtractName(fullName) + ".res"
# cmd = interpreter + " < " + inNm + " > " + outNm
# return util.RunCommand(cmd, 0, "Error while stripping semantic values")
return util.WriteFile(outNm, util.ReadFile(inNm))
def TranslateResultSpec(fullName):
bn = util.ExtractName(fullName)
testName = bn + ".arg.res"
data = util.ReadFile(testName)
if data == None:
return None
return TranslateResultCommon(data)
def RunSpecTestCases(fullNames, lang, dtc, coverageFile):
# remove files we expect output in to.
for fullName in fullNames:
util.RemoveTestFiles(fullName, [".arg.pt", ".arg.res", ".arg.err", ".arg.msg"])
# run the test cases
interpreter = cmdline.LookUpWildCard('pog', lang, 'spec', 'interpreter')
# cmd = interpreter + " -a -b -R " + coverageFile + " ../pog/test.vdm"
cmd = interpreter + " -a -b -R " + coverageFile
exitCode = util.RunCommand(cmd, 0, "Possible core dump while interpreting specification.")
okNames = []
# Now validate the results
for fullName in fullNames:
bn = util.ExtractName(fullName)
semResName = bn + ".arg.res"
resName = bn + ".res"
errName = bn + ".arg.msg"
report.setTestCaseName(fullName)
# See if a result file was created
if not os.path.exists(semResName) and not os.path.exists(errName):
report.Error("No result or error file generated for test case " + fullName,
"Maybe the interpreting toolbox failed for one of the previous test cases")
continue
# Find expected result file
ok = true
expResultFile = FindResFile(fullName)
if expResultFile == None:
ok = false
if os.path.exists(errName):
# See if an error file is generated.
data = util.ReadFile(errName)
if data == None:
continue
# Note the order of the next binary expression ensures that
# CompareRunTimeError is executed even though no expected result was
# found! This is necesary as this function generates the result one
# can copy in place
ok = CompareRunTimeError(fullName, expResultFile, data) and ok
else:
# Strip sem values
ok = ok and StripSemValue(fullName, lang, dtc)
# validate expected result then
if ok:
interpreter = cmdline.LookUpWildCard('pog', lang, 'spec', 'spec-compare')
ok = CompareResult(fullName, resName, expResultFile, interpreter)
if ok:
okNames.append(fullName)
return okNames
def GetPackage(fullName):
data = util.ReadFile(fullName)
if data == None:
return ""
regexp = re.compile("^package (.*)\s*;", re.M)
match = regexp.search(data, 0)
if match == None:
return ""
else:
report.Progress(4,
"Found package " + match.group(1) + " in " + fullName)
return match.group(1)
def CompareRunTimeError(fullName, resFile):
report.Progress(4,"Searching for runtime error")
bn = util.ExtractName(fullName)
actualResult = util.ReadFile(bn+".res")
if actualResult == None:
return None
if string.find(actualResult, "Run-Time Error") != -1:
#expectedResult = util.ReadFile(resFile)
expectedResult = string.rstrip(util.ReadFile(resFile), "\n")
ok = (string.find(expectedResult, "Run-Time Error") != -1)
if ok:
actualResult = string.strip(re.sub("\s+", " ", actualResult))
expectedResult = re.sub("Run-Time Error[ 0-9]*: ", "Run-Time Error:", expectedResult)
#expectedResult = string.strip(re.sub("\s+", " ", expectedResult))
ok = (actualResult == expectedResult)
if not ok:
report.Error("Actual result is different from expected result for " + `fullName`,
"expected result : " + expectedResult + "\n" +
"actual result : " + actualResult)
return ok
else:
return None
def SetupArgFile(fullName,lang):
argNm = util.StripExt(fullName)+".arg"
localNm = util.ExtractName(fullName)+".arg"
if os.path.exists(argNm):
data = util.ReadFile(argNm)
if data == None:
return false
if lang != 'sl':
data = re.sub("^(.*)`(.*)\s*$", "new \\1().\\2", data, re.M)
util.DeleteFiles([localNm])
return util.WriteFile(localNm, data)
else:
argFile = sys.path[0]+"/ip-files/iprun-" + lang + ".arg"
return util.CopyFile(argFile,localNm)
def ConvertLanguage(lang, fileName):
newName = util.ExtractName(fileName) + ".vdm"
report.Progress(4, "Converting testcase to language " + lang + " (creating " + newName +")")
data = util.ReadFile(fileName)
if data == None:
return false
if IsLanguageSl(data):
if (lang == 'pp'):
report.Error("Input file: '" + fileName + "' is a SL file, but a PP file is required")
return false
else:
if (lang == 'sl'):
data = PP2SL(data)
ok = util.WriteFile(newName, data)
return ok
def CreateArgFile(fileName, templateName, extra):
argFile = util.ExtractName(fileName) + ".arg"
astFile = util.ExtractName(fileName) + ".ast"
report.Progress(4, "Creating arg file (" + argFile +")")
template = util.GetTemplate(templateName)
if template == None:
return false
ast = util.ReadFile(astFile)
if ast == None:
return false
data = util.SubString('<<AST>>', ast, template)
for key in extra.keys():
data = util.SubString(key, extra[key], data)
ok = util.WriteFile(argFile, data)
return ok
def RunApiTestCase(name, lang, toolMediator):
data = util.ReadFile(name)
baseName = util.ExtractName(name)
neutralName = re.sub('.*/', '', name) # path neutralized!
result = baseName + ":\n"
last = ""
symTable = {}
symTable['GENPATH'] = os.path.expanduser(cmdline.LookUp('api-gen-path'))
symTable['SOURCEPATH'] = os.path.expanduser(
cmdline.LookUp('api-source-path'))
print(symTable['GENPATH'])
print(symTable['SOURCEPATH'])
commands = data.split("\n")
line, test = 0, 0
empty = re.compile('^\s*(#.*)|(\s*)$')
interactive_mode = cmdline.LookUp('api-run-interactive')
for cmd in commands:
print("Command: " + cmd)
if interactive_mode == 'yes':
print("Press <return>")
raw_input()
line = line + 1
# don't process empty lines
if not empty.match(cmd):
test = test + 1
try:
cmd = re.sub('\$\$', last, cmd) # replace $$ by last result
cmd = re.sub('\s+', ' ',
cmd).strip() # replace multiple spaces by one
cmd = re.sub('\s*\(\s*', '(',
cmd) # delete spaces around parentheses
cmd = re.sub('\s*\)\s*', ')', cmd)
cmd = re.sub('\s*\[\s*', '[',
cmd) # delete spaces around parentheses
cmd = re.sub('\s*\]\s*', ']', cmd)
cmd = re.sub('\s*,\s*', ',',
cmd) # delete spaces around commas
cmd = re.sub('\s*=\s*', '=', cmd) # delete spaces around =
# find variable assignment
m = re.compile('^\$(?P<lval>\w+)=(?P<rval>.*)$').match(cmd)
if m != None:
lval = m.group('lval')
cmd = m.group('rval')
else:
lval = ""
# find variable usages and replace them by value
m = re.compile('^.*\$(?P<id>\w+).*$').match(cmd)
if m != None:
while m != None:
var = "\$" + m.group('id')
try:
repl = symTable[m.group('id')]
except KeyError:
raise Syntax("Unknown variable name $" + var)
cmd = re.sub(var, repl, cmd)
m = re.compile('^.*\$(?P<id>\w+).*$').match(cmd)
result = result + "-- " + str(test) + "(in line " + str(
line) + "):\n"
# print (cmd)
# parse and execute the command
last = toolMediator.ParseCommand(cmd, name, line)
lines = last.split('\n')
pathexp = re.compile('^.*/(.*\.(vdm|vpp|api))$')
for l in lines:
# neutralize path
result = result + pathexp.sub(r'\1', l) + "\n"
last = re.sub('\n$', '', last)
last = re.sub('\n', ',', last).strip()
if lval != "":
symTable[lval] = last
except CORBA.COMM_FAILURE:
raise CORBA.COMM_FAILURE
except CORBA.BAD_PARAM:
result = result + "CORBA.BAD_PARAM in " + neutralName + ", line " + str(
line) + "\n"
except ToolboxAPI.APIError:
_, e, _ = sys.exc_info()
result = result + "APIError in " + neutralName + ", line " + str(
line) + ": " + e.msg + "\n"
except VDM.VDMError:
_, e, _ = sys.exc_info()
result = result + "VDMError in " + neutralName + ", line " + str(
line) + ": " + str(e.err) + "\n"
except Syntax:
_, e, _ = sys.exc_info()
result = result + "Syntax error in " + neutralName + ", line " + str(
line) + ": " + e.GetMessage() + "\n"
except CORBA.UserException:
result = result + "CORBA.UserException: in " + baseName + ".api, line " + str(
line) + "\n"
except CORBA.SystemException:
_, e, _ = sys.exc_info()
print(e)
result = result + "CORBA.SystemException: in " + baseName + ".api, line " + str(
line) + "\n"
except Exception:
_, e, _ = sys.exc_info()
print("Python exception")
print(e.args)
result = result + "Python exception in " + baseName + ".api, line " + str(
line) + "\n"
except:
result = result + "Unknown exception in " + baseName + ".api, line " + str(
line) + "\n"
ok = util.WriteFile(baseName + ".tmp", result)
if ok:
resFile = resfile.FindResFile(name)
ok = (resFile != None)
if ok:
ok = resfile.CompareResult(name, baseName + ".tmp", resFile, None)
if util.CleanFile(ok):
util.DeleteFiles([baseName + ".tmp"])
return ok
def PrepareSpecCaseDir(dirName, lang):
global runJavacBeforeParser
testName = GetTestName(dirName)
fullName = os.getcwd()
#
# Produce a list of java files in dirName
# and put it testCases
#
AddTestsFromHierarchy(dirName, lang)
util.DeleteFiles([parseRes])
util.RemoveTestFiles(testName, [
".arg.pt", ".arg.res", ".arg.err", ".res.arg", ".arg.msg", "vpp.arg",
".res", ".debug", ".ast"
])
ok = convert.CreateOptionsFile(fullName)
if runJavacBeforeParser == "yes":
ok = CompileJavaFiles(dirName)
if not ok:
return false
javafiles = " "
javafiles = javafiles + setup.BaseDir + "/../j2v-test/Object.java "
javafiles = javafiles + setup.BaseDir + "/../j2v-test/Exception.java "
javafiles = javafiles + setup.BaseDir + "/../j2v-test/String.java "
javafiles = javafiles + setup.BaseDir + "/../j2v-test/Character.java "
#
# Iterate over the list of java files in the dirName (except MAIN.java)
# and runs javamain
#
mainJava = dirName + "/" + "MAIN.java"
while ok and (testCases != []):
test = GetNextTest()
if os.path.abspath(test) != os.path.abspath(mainJava):
javafiles = javafiles + test + " "
# javafiles = javafiles + setup.BaseDir+"/../j2v-test/Object.java "
# javafiles = javafiles + setup.BaseDir+"/../j2v-test/Exception.java "
# javafiles = javafiles + setup.BaseDir+"/../j2v-test/String.java "
#
# Run java parser to get CPP`Files
#
if not ParseJavaFile(javafiles, lang):
ok = false
if ok:
ast = util.ReadFile(parseRes)
if ok:
ok = util.WriteFile(testName + ".ast", ast)
if ok:
convert.CreateDebugFile(dirName, "debug-file-java2vdm", {})
if ok:
ok = convert.CreateArgFile(dirName, "arg-file-java2vdm", {})
if ok:
ok = convert.AppendToDotVdmtest(dirName)
# Clean up if test case failed
if not ok and util.CleanFile(ok):
util.DeleteFiles([
testName + ".vdm", testName + ".ast", testName + ".arg",
testName + ".debug", "debug.arg"
])
return ok
def RunSpecTestCases(fullNames, lang, coverageFile):
global vdmde, speccompare, backend, javac, java, vppde
global staticSemanticsOnly, parserOnly
testvdm = "test-j2v.vdm"
if parserOnly == "yes":
testvdm = "test-javamain.vdm"
if staticSemanticsOnly == "yes":
testvdm = "test-jss.vdm"
testvdm = setup.BaseDir + "/../j2v-test/" + testvdm
cmd = vdmde + " -DP -a -b -R " + coverageFile + " " + testvdm
(exitCode, dummy1, dummy2) = util.RunCommand(
cmd, 0, "Possible core dump while interpreting specification.", true)
ok = exitCode == 0
if exitCode != 0:
report.Error("Toolbox returns an error ", "'" + dummy1 + "'")
if ok and dummy1.find("Run-Time Error") != -1:
report.Error(
"Toolbox returns an run-time error. Look for the latest .arg.err file ",
"")
modules = []
if parserOnly == "no" and ok:
#
# Run backend for the VDM++ AS value to get
# VDM++ concrete syntax
#
for fullName in fullNames:
bn = GetTestName(fullName)
semResName = bn + ".arg.res"
if not os.path.exists(semResName):
continue
if staticSemanticsOnly == "yes":
util.CopyFile(semResName, fullName + "/" + semResName)
report.setTestCaseName(fullName)
modules.append(fullName)
#
# The second arg should be directory where to put all
# generated .vpp
#
if staticSemanticsOnly == "no":
if AS2CS(semResName, os.getcwd()):
#
# Run java to produce expected result
#
expRes = os.getcwd() + "/" + GetTestName(
fullName) + ".res.exp"
#
# If test directory contains its own MAIN.java, use it,
# otherwise, use the generic MAIN.java in the current dir
#
j2vutilJava = setup.BaseDir + "/../j2v-test/J2VUTIL.java"
genericMainJava = setup.BaseDir + "/../j2v-test/MAIN.java"
mainJava = fullName + "/MAIN.java"
if not os.path.exists(mainJava):
mainJava = genericMainJava
javaFiles = fullName + "/*.java " + mainJava + " " + j2vutilJava + " "
#
# Compile MAIN.java and J2VUTIL.java using
# classes of test java files prepared earlier
#
if not util.IsWindowsOS():
cmd = javac + " -d " + os.getcwd() + " " + javaFiles
else:
cmd = javac + " -classpath ./VDM.jar -d ./ " + javaFiles
(exitCode, dummy1,
dummy2) = util.RunCommand(cmd, 0,
"Javac returns errors. ")
if exitCode != 0:
break
if not util.IsWindowsOS():
cmd = java + " -classpath $CLASSPATH:" + os.getcwd(
) + " MAIN"
else:
cmd = java + " MAIN"
(exitCode, dummy1,
dummy2) = util.RunCommand(cmd, 0, "Java returns errors. ",
true)
if exitCode != 0:
break
if not util.WriteFile(expRes, dummy1):
break
#
# Run vppde to produce the result itself
#
prefix = os.getcwd() + "/" + GetTestName(fullName)
res = bn + ".res"
vpparg = "vpp.arg"
#
# Create arg file
#
util.WriteFile(vpparg, "new A().Test()")
objectVpp = setup.BaseDir + "/../j2v-test/Object.vpp"
vppFiles = ""
if not util.IsWindowsOS():
FID = os.popen("find " + os.getcwd() +
" -type f -name \*.vpp")
else:
FID = os.popen("find ./ -type f -name \*.vpp")
line = FID.readline()
while (line != ''):
vppFiles = vppFiles + line[:-1] + " "
line = FID.readline()
vppFiles = vppFiles + " " + objectVpp
cmd = vppde + " -iD -O " + res + " " + vpparg + " " + vppFiles
(exitCode, dummy1,
dummy2) = util.RunCommand(cmd, 0,
"Vppde returns errors. ", true)
if exitCode != 0:
report.Error("Vppde returns errors " + fullName, "")
filesToDelete = []
FID = os.popen("ls *.vpp *.class 2>/dev/null")
line = FID.readline()
while (line != ''):
filesToDelete.append(line[:-1])
line = FID.readline()
util.DeleteFiles(filesToDelete)
okNames = []
#
# Now validate the results
#
for fullName in fullNames:
argErr = bn + ".arg.err"
semResName = bn + ".arg.res"
resName = bn + ".res"
expSemResName = fullName + "/" + bn + ".arg.res.exp"
expResName = bn + ".res.exp"
report.setTestCaseName(fullName)
ok = true
if ok and staticSemanticsOnly == "no" and parserOnly == "no":
if not os.path.exists(resName):
report.Error(
"No result file generated for test case " + fullName,
"Maybe the code generation failed for " +
"one of the previous test cases")
ok = false
if ok:
if staticSemanticsOnly == "no" and parserOnly == "no":
if os.path.exists(expResName):
ok = resfile.CompareResult(bn, resName, expResName,
speccompare, false)
else:
if staticSemanticsOnly == "yes" and parserOnly == "no":
if os.path.exists(semResName):
ok = resfile.CompareResult(bn, semResName,
expSemResName, speccompare,
false)
else:
report.Error(
"No result file generated for test case " + fullName,
"Look for the latest .arg.err file ")
ok = false
if parserOnly == "yes":
if os.path.exists(argErr):
errorText = util.ReadFile(argErr)
if errorText != "":
report.Error("Parser failure " + fullName,
errorText)
if ok:
okNames.append(fullName)
return (okNames, modules)
def GetTemplate(name):
global templates
if not templates.has_key(name):
templates[name] = util.ReadFile(setup.BaseDir + "/templates/" + name)
return templates[name]
def RunApiTestCase(name, lang, toolMediator):
data = util.ReadFile(name)
baseName = util.ExtractName(name)
neutralName = re.sub('.*/', '', name) # path neutralized!
result = baseName + ":\n"
last = ""
symTable = {}
symTable['GENPATH'] = os.path.expanduser(cmdline.LookUp('api-gen-path'))
symTable['SOURCEPATH'] = os.path.expanduser(
cmdline.LookUp('api-source-path'))
print symTable['GENPATH']
print symTable['SOURCEPATH']
commands = string.split(data, "\n")
line, test = 0, 0
empty = re.compile('^\s*(#.*)|(\s*)$')
interactive_mode = cmdline.LookUp('api-run-interactive')
for cmd in commands:
print "Command: ", cmd
if interactive_mode == 'yes':
print "Press <return>"
raw_input()
line = line + 1
# don't process empty lines
if not empty.match(cmd):
test = test + 1
try:
cmd = re.sub('\$\$', last, cmd) # replace $$ by last result
cmd = string.strip(re.sub(
'\s+', ' ', cmd)) # replace multiple spaces by one
cmd = re.sub('\s*\(\s*', '(',
cmd) # delete spaces around parentheses
cmd = re.sub('\s*\)\s*', ')', cmd)
cmd = re.sub('\s*\[\s*', '[',
cmd) # delete spaces around parentheses
cmd = re.sub('\s*\]\s*', ']', cmd)
cmd = re.sub('\s*,\s*', ',',
cmd) # delete spaces around commas
cmd = re.sub('\s*=\s*', '=', cmd) # delete spaces around =
# find variable assignment
m = re.compile('^\$(?P<lval>\w+)=(?P<rval>.*)$').match(cmd)
if m <> None:
lval = m.group('lval')
cmd = m.group('rval')
else:
lval = ""
# find variable usages and replace them by value
m = re.compile('^.*\$(?P<id>\w+).*$').match(cmd)
if m <> None:
while m <> None:
var = "\$" + m.group('id')
try:
repl = symTable[m.group('id')]
except KeyError:
raise Syntax("Unknown variable name $" + var)
cmd = re.sub(var, repl, cmd)
m = re.compile('^.*\$(?P<id>\w+).*$').match(cmd)
result = result + "-- " + ` test ` + "(in line " + ` line ` + "):\n"
# print cmd + "\n"
# parse and execute the command
last = toolMediator.ParseCommand(cmd, name, line)
lines = string.split(last, '\n')
pathexp = re.compile('^.*/(.*\.(vdm|vpp|api))$')
for l in lines:
# neutralize path
result = result + pathexp.sub(r'\1', l) + "\n"
last = re.sub('\n$', '', last)
last = string.strip(re.sub('\n', ',', last))
if lval <> "":
symTable[lval] = last
except CORBA.COMM_FAILURE:
raise CORBA.COMM_FAILURE
except CORBA.BAD_PARAM:
result = result + "CORBA.BAD_PARAM in " + neutralName + ", line " + ` line ` + "\n"
except ToolboxAPI.APIError, e:
result = result + "APIError in " + neutralName + ", line " + ` line ` + ": " + e.msg + "\n"
except VDM.VDMError, e:
result = result + "VDMError in " + neutralName + ", line " + ` line ` + ": " + ` e.err ` + "\n"
except Syntax, e:
result = result + "Syntax error in " + neutralName + ", line " + ` line ` + ": " + e.GetMessage(
) + "\n"
def GetKey(self, version_number):
return util.ReadFile(os.path.join(self._location, str(version_number)))
def GetMetadata(self):
return util.ReadFile(os.path.join(self._location, "meta"))
def CompareResult(fullName, outputFile, resFile, interpreter, structTest=true):
# compare the results using normal "diff"
actualResult = util.ReadFile(outputFile)
expectedResult = util.ReadFile(resFile)
# Remove duplicate white spaces and line breaks, spaces around commas and parenthesis.
actualResult = re.sub("\s+", " ", actualResult).strip()
expectedResult = re.sub("\s+", " ", expectedResult).strip()
actualResult = re.sub("\s*,\s*", ",", actualResult).strip()
expectedResult = re.sub("\s*,\s*", ",", expectedResult).strip()
actualResult = re.sub("\s*\(\s*", "(", actualResult).strip()
expectedResult = re.sub("\s*\(\s*", "(", expectedResult).strip()
actualResult = re.sub("\s*\)\s*", ")", actualResult).strip()
expectedResult = re.sub("\s*\)\s*", ")", expectedResult).strip()
if actualResult == expectedResult:
return true
# Expected Result is Run Time Error
if expectedResult.startswith("Run-Time Error"):
report.Error(
"Actual result is different from expected result for '" +
fullName + "'", "expected result : " + expectedResult + "\n" +
"actual result : " + actualResult)
return false
if expectedResult.startswith(
"<UTIL.NumberToInt>:") or actualResult.startswith(
"<UTIL.NumberToInt>:"):
report.Error(
"Actual result is different from expected result for '" +
fullName + "'", "expected result : " + expectedResult + "\n" +
"actual result : " + actualResult)
return false
if expectedResult.startswith(
"The construct is not supported:") or actualResult.startswith(
"The construct is not supported:"):
report.Error(
"Actual result is different from expected result for '" +
fullName + "'", "expected result : " + expectedResult + "\n" +
"actual result : " + actualResult)
return false
report.Progress(
4, "Comparing result for '" + fullName + "' using diff method")
# Hmmm we need to try to compare using VDMDE then.
if structTest and interpreter != None:
report.Progress(
4, "Comparing result for '" + fullName + "' by build VDM value")
template = util.GetTemplate("compare-result")
if template == None:
return false
data = util.SubString('<<EXPECTED_RESULT>>', expectedResult, template)
data = util.SubString('<<ACTUAL_RESULT>>', actualResult, data)
ok = util.WriteFile("compare.vdm", data)
if not ok:
return false
util.CopyFile(setup.BaseDir + "/general-files/compare.arg",
"compare.arg")
cmd = interpreter + " -i compare.arg compare.vdm"
(exitcode, dummy1, dummy2) = util.RunCommand(cmd)
ok = (exitcode == 0)
else:
ok = false
if not ok:
report.Error(
"Actual result is different from expected result for '" +
fullName + "'", "expected result : " + expectedResult + "\n" +
"actual result : " + actualResult)
if util.CleanFile(ok):
util.DeleteFiles(["comapre.arg"])
return ok
def ModulesInSpecification(fullName, lang):
global uselibs, standardlibs
localName = util.ExtractName(fullName)+".vdm"
data = util.ReadFile(localName)
if data == None:
return None
if lang == 'sl':
keyword = 'module '
else:
keyword = 'class '
regexp = re.compile("^\s*" + keyword + "\s*(\w+)", re.M)
index = 0
result = []
finished = 0
standardlibs = []
while finished != 1:
match = regexp.search(data, index)
if match == None:
if result == []:
report.Error("Could find any module or class in specification file '" + fullName + "'")
return None
finished = 1
else:
report.Progress(4,"Found module " + match.group(1))
if IsStandardLib(match.group(1)):
standardlibs.append(match.group(1))
result.append(match.group(1))
index = match.end()
# If this is VDM-SL, return immediately, as we do not yet support
# dlmodules in the test environment. FIXME
if lang == 'sl':
return result
# Accumulate those modules that are dlclasses in uselibs
keyword = 'dlclass'
regexp1 = re.compile("^\s*" + keyword + "\s*(\w+)", re.M)
regexp2 = re.compile("^\s*" + "uselib" + "\s*(\".+\")", re.M)
index = 0
finished = 0
uselibs = []
while finished != 1:
match = regexp1.search(data, index)
if match == None:
finished = 1
else:
report.Progress(4,"Found dlclass " + match.group(1))
result.append(match.group(1))
uselib = regexp2.search(data, match.start())
if uselib == None:
report.Progress(4,"No uselib found for dlclass " + match.group(1))
else:
uselibs.append(uselib.group(1))
index = match.end()
return result
def ParseOptionsFile(fileName):
filestem = util.StripExt(fileName)
optionsFileName = filestem + '.opt'
if not os.path.exists(optionsFileName):
return ""
report.Progress(4, "Parsing " + optionsFileName)
data = util.ReadFile(optionsFileName)
startIndex = data.find("SetOptions")
if startIndex == -1:
report.Error("Unable to parse options file (1)")
return ""
reStart = re.compile("==\s+");
startMatch = reStart.search(data, startIndex)
if startMatch == None:
report.Error("Unable to parse options file (2)")
return ""
startIndex = startMatch.start()
reEnd = re.compile(";?\s*end\s+OPTIONS", re.M)
endMatch = reEnd.search(data, startIndex)
if endMatch == None: #Ill formed options file
report.Error("Unable to parse options file (3)")
return ""
interfacesFlag = "-U"
interfaceSeparator = ','
packageFlag = "-z"
endIndex = endMatch.start() - 1
commands = re.split(';',data[startIndex:endIndex])
commstring = ""
for comm in commands:
report.Progress(4, "**> command is" + comm)
reComName = re.compile("CGMAIN`(\w+)")
commMatch = reComName.search(comm,0)
if commMatch != None:
commandName = commMatch.group(1)
if commandName == "set_interfaces":
reArgs = re.compile("mk_AS`Name\(\[\"(\w+)\"],-1\)")
args = comm[commMatch.end()+1:]
arglist = ""
nextArg = reArgs.search(args,0)
while nextArg != None:
if arglist == "":
arglist = " " + nextArg.group(1)
else:
arglist = arglist + interfaceSeparator + nextArg.group(1)
nextArg = reArgs.search(args, nextArg.end()+1)
commstring = commstring + ' ' + interfacesFlag + arglist
elif commandName == "set_package_option":
report.Progress(4, "Command is set_package_option")
reArgs = re.compile("\"([\.\w]*)\"")
args = comm[commMatch.end()+1:]
arg = reArgs.search(args, 0)
if arg != None:
commstring = commstring + ' ' + packageFlag + " " + arg.group(1)
else:
report.Error("args didn't match: " + args)
else:
print ("Unknown option " + comm)
else:
report.Error("Command didn't match: " + comm)
report.Progress(4, "Finished parsing " + optionsFileName)
return commstring
