public override bool Walk(FromImportStatement node)
{
if (node.StartIndex <= Location && Location <= node.EndIndex)
{
var nameNode = node.Names.MaybeEnumerate().Where(n => n.StartIndex <= Location && Location <= n.EndIndex).FirstOrDefault();
if (nameNode != null && node.AsNames != null)
{
var index = node.Names.IndexOf(nameNode);
if (index < node.AsNames.Count && node.AsNames[index] != null)
{
ImportedType = GetNamedLocation(node.AsNames[index]);
return(false);
}
}
var modName = node.Root.MakeString();
// See if we can resolve relative names
var candidates = ModuleResolver.ResolvePotentialModuleNames(_importingFromModuleName, _importingFromFilePath, modName, node.ForceAbsolute).ToArray();
if (candidates.Length == 1 && string.IsNullOrEmpty(candidates[0]) && node.Names != null && node.Names.Any())
{
// Did not resolve to anything. Happens at the top of the workspace
// in VS Code when using 'from . import a'
ImportedModules = new[] { GetNamedLocation(node.Names.First()) };
}
else if (candidates.Length > 0)
{
ImportedModules = candidates.Select(c => GetNamedLocation(c, node.Root)).ToArray();
}
else
{
ImportedModules = new[] { GetNamedLocation(modName, node.Root) };
}
}
return(false);
}
public void Image(string input, string resolveDll, string resolveType)
{
resolveDll = Server.MapPath("~/Scripts/TestsFolder/" + resolveDll);
IImageTestEndpoints endpoint = ModuleResolver.GetImageDll(resolveDll, resolveType);
Bitmap bitmap = endpoint.GetImage(input);
Response.ContentType = "image/bmp";
bitmap.Save(Response.OutputStream, ImageFormat.Bmp);
}
public void ResolveRouteInformation(Assembly assembly)
{
var route = new ControllerExecuter.ControllerExecuter(assembly);
ModuleResolver resolver = new ModuleResolver(assembly);
var moduleName = resolver.GetModuleManifest().Name;
Routes.RemoveAll(m => m.ModuleName.Equals(moduleName, StringComparison.OrdinalIgnoreCase));
ResolveRoutes(assembly, resolver.GetModuleManifest());
AddRedirections(resolver.GetModuleManifest());
}
public override bool Walk(FromImportStatement node)
{
if (node.StartIndex <= Location && Location <= node.EndIndex)
{
// Determine if location is over imported parts such as
// over 'a' in 'from . import a, b, c' or over 'x' in 'from a import x'
// and store module names and imported parts
ImportedModules = ModuleResolver.ResolvePotentialModuleNames(_importingFromModuleName, _importingFromFilePath, node.Root.MakeString(), node.ForceAbsolute);
}
return(false);
}
private void AssertModuleResolver()
{
if (moduleResolver == null)
{
DirectoryInfo modulesDirectory = null;
if (!string.IsNullOrWhiteSpace(ModulesDirectoryPath))
{
modulesDirectory = new DirectoryInfo(ModulesDirectoryPath);
}
moduleResolver = new ModuleResolver(enabledModules, modulesDirectory);
}
}
private void GetTheme(ModuleResolver resolver)
{
string ModuleName = resolver.GetModuleManifest().Name;
try
{
var theme = resolver.Assembly.GetThemeProvider();
ThemeProviders[ModuleName] = theme;
CurrentThemeProvider = ModuleName;
}
catch { }
}
private bool TryImportModule(string modName, bool forceAbsolute, out ModuleReference moduleRef, out IReadOnlyList <string> remainingParts)
{
moduleRef = null;
remainingParts = null;
if (ProjectState.Limits.CrossModule > 0 &&
ProjectState.ModulesByFilename.Count > ProjectState.Limits.CrossModule)
{
// too many modules loaded, disable cross module analysis by blocking
// scripts from seeing other modules.
return(false);
}
var candidates = ModuleResolver.ResolvePotentialModuleNames(_unit.ProjectEntry, modName, forceAbsolute).ToArray();
foreach (var name in candidates)
{
if (ProjectState.Modules.TryImport(name, out moduleRef))
{
return(true);
}
}
foreach (var name in candidates)
{
moduleRef = null;
foreach (var part in ModulePath.GetParents(name, includeFullName: true))
{
if (ProjectState.Modules.TryImport(part, out var mref))
{
moduleRef = mref;
if (part.Length < name.Length)
{
moduleRef.Module?.Imported(_unit);
}
}
else if (moduleRef != null)
{
Debug.Assert(moduleRef.Name.Length + 1 < name.Length, $"Expected {name} to be a child of {moduleRef.Name}");
if (moduleRef.Name.Length + 1 < name.Length)
{
remainingParts = name.Substring(moduleRef.Name.Length + 1).Split('.');
}
return(true);
}
else
{
break;
}
}
}
return(moduleRef?.Module != null);
}
private bool TryImportModule(string modName, bool forceAbsolute, out ModuleReference moduleRef, out IReadOnlyList <string> remainingParts)
{
moduleRef = null;
remainingParts = null;
if (ProjectState.Limits.CrossModule > 0 &&
ProjectState.ModulesByFilename.Count > ProjectState.Limits.CrossModule)
{
// too many modules loaded, disable cross module analysis by blocking
// scripts from seeing other modules.
return(false);
}
var candidates = ModuleResolver.ResolvePotentialModuleNames(_unit.ProjectEntry, modName, forceAbsolute).ToArray();
foreach (var name in candidates)
{
ModuleReference modRef;
bool gotAllParents = true;
AnalysisValue lastParent = null;
remainingParts = name.Split('.');
foreach (var part in ModulePath.GetParents(name, includeFullName: false))
{
if (!ProjectState.Modules.TryImport(part, out modRef))
{
gotAllParents = false;
break;
}
moduleRef = modRef;
(lastParent as BuiltinModule)?.AddChildModule(remainingParts[0], moduleRef.AnalysisModule);
lastParent = moduleRef.AnalysisModule;
remainingParts = remainingParts.Skip(1).ToArray();
}
if (gotAllParents && ProjectState.Modules.TryImport(name, out modRef))
{
moduleRef = modRef;
(lastParent as BuiltinModule)?.AddChildModule(remainingParts[0], moduleRef.AnalysisModule);
_unit.DeclaringModule.AddModuleReference(moduleRef);
remainingParts = null;
return(true);
}
}
if (moduleRef?.Module != null)
{
_unit.DeclaringModule.AddModuleReference(moduleRef);
return(true);
}
return(false);
}
public void CompileMultipleSourcesErrors(string source0, string source1)
{
var sources = new Source[] {
new Source(new Uri("source0"), source0),
new Source(new Uri("source1"), source1)
};
var cflat = new CFlat();
var moduleResolver = new ModuleResolver(sources);
var errors = cflat.CompileSource(sources[0], TestHelper.CompilerMode, moduleResolver);
Assert.NotEqual(0, errors.count);
}
public override bool Walk(FromImportStatement node)
{
var names = ModuleResolver.GetModuleNamesFromImport(_entry, node);
foreach (var n in names)
{
if (!_analyzer.IsModuleResolved(_entry, n, node.ForceAbsolute))
{
Diagnostics.Add(MakeUnresolvedImport(n, node.Root));
}
}
return(base.Walk(node));
}
private ModuleResolver AddModule(byte[] dllBytes, bool ignoreDependencyIndexUpdate = true)
{
var resolver = new ModuleResolver(dllBytes);
var manifest = resolver.GetModuleManifest();
if (ignoreDependencyIndexUpdate)
{
UpdateDependencyIndex(manifest);
}
GetTheme(resolver);
ModuleManager.AddModule(manifest, resolver.Assembly);
RouterManager.ResolveRouteInformation(resolver.Assembly);
AuthenticationManager.Upload(dllBytes);
return(resolver);
}
public void CompileMultipleSourcesTests(string source0, string source1)
{
var sources = new Source[] {
new Source(new Uri("source0"), source0),
new Source(new Uri("source1"), source1)
};
var cflat = new CFlat();
var moduleResolver = new ModuleResolver(sources);
var errors = cflat.CompileSource(sources[0], TestHelper.CompilerMode, moduleResolver);
if (errors.count > 0)
{
throw new CompileErrorException(cflat.GetFormattedCompileErrors());
}
}
public ActionResult CurrentFile(int testId, string dllFile, string resolveType, int testFileNumber)
{
FileInfo[] files = this.GetTestFiles(testId);
string description = "";
using (FileStream fs = files[testFileNumber].OpenRead())
{
using (StreamReader sr = new StreamReader(fs))
{
ITransform transform = ModuleResolver.GetTransformDll(Server.MapPath("~/Scripts/TestsFolder/" + dllFile), resolveType);
description = transform.TransformFileToClient(sr.ReadToEnd());
}
}
DescriptionReg descr = new DescriptionReg()
{
Description = description
};
return(Json(descr));
}
public ActionResult CompareResultsSimple(string result)
{
ResolveInformation inf = new JavaScriptSerializer().Deserialize <ResolveInformation>(result);
inf.DllFilePath = Server.MapPath("~/Scripts/TestsFolder/" + inf.DllFilePath);
ITestEndpoints testModule = ModuleResolver.GetAppDll(inf.DllFilePath, inf.ResolveDllType);
string gradeResult = testModule.Grade(result);
TestEntity test = testService.GetTestById(inf.Id);
AnswerEntity answerEnt = new AnswerEntity()
{
Content = System.Text.Encoding.Default.GetBytes(result),
Mark = Double.Parse(gradeResult),
TestId = test.Id,
UserId = userService.GetUserByEmail(User.Identity.Name).Id,
TestEndTime = DateTime.Now
};
testService.CreateAnswer(answerEnt);
return(Json(new { Mark = gradeResult }));
}
public void SimpleTypesTest(int numberOfTypes, ModuleResolver moduleResolver, params Type[] types)
{
var module = ModuleHelper.LoadModule <EmptyClass>();
var moduleResolverInstance = moduleResolver == ModuleResolver.AssemblyModuleResolver
? (IModuleResolver) new AssemblyModuleResolver(typeof(TomsToolbox.Core.AssemblyExtensions).Assembly, typeof(TomsToolbox.Core.DefaultValue).Assembly)
: new LocalReferenceModuleResolver();
var targetAssemblyPath = Path.Combine(TestHelper.TempPath, "TargetAssembly1.dll");
var target = new CodeImporter(module)
{
ModuleResolver = moduleResolverInstance,
HideImportedTypes = false,
CompactMode = false
};
foreach (var type in types)
{
target.Import(type);
}
module.Write(targetAssemblyPath);
var importedTypes = target.ListImportedTypes();
foreach (var type in importedTypes)
{
_testOutputHelper.WriteLine(type.Key.FullName);
}
var importedModules = target.ListImportedModules();
Assert.True(TestHelper.PEVerify.Verify(targetAssemblyPath, _testOutputHelper));
Assert.Equal(numberOfTypes, importedTypes.Count);
TestHelper.VerifyTypes(importedTypes, importedModules, targetAssemblyPath);
}
/**
* Run a test case
*
* @param testCase the test case element in the catalog
* @param xpc the XPath compiler to be used for compiling XPath expressions against the catalog
* @throws SaxonApiException
*/
private void runTestCase(XdmNode testCase, XPathCompiler xpc)
{
string testCaseName = testCase.GetAttributeValue(new QName("name"));
feedback.Message("Test case " + testCaseName + Environment.NewLine, false);
XdmNode exceptionElement = null;
try
{
exceptionElement = exceptionsMap[testCaseName];
}
catch (Exception) { }
XdmNode alternativeResult = null;
XdmNode optimization = null;
if (exceptionElement != null)
{
string runAtt = exceptionElement.GetAttributeValue(new QName("run"));
if ("no".Equals(runAtt))
{
WriteTestCaseElement(testCaseName, "notRun", "see exceptions file");
return;
}
if (unfolded && "not-unfolded".Equals(runAtt))
{
WriteTestCaseElement(testCaseName, "notRun", "see exceptions file");
return;
}
alternativeResult = (XdmNode)xpc.EvaluateSingle("result", exceptionElement);
optimization = (XdmNode)xpc.EvaluateSingle("optimization", exceptionElement);
}
XdmNode environmentNode = (XdmNode)xpc.EvaluateSingle("environment", testCase);
TestEnvironment env = null;
if (environmentNode == null)
{
env = localEnvironments["default"];
}
else
{
string envName = environmentNode.GetAttributeValue(new QName("ref"));
if (envName == null)
{
env = processEnvironment(xpc, environmentNode, null);
}
else
{
try
{
env = localEnvironments[envName];
}
catch (Exception) { }
if (env == null)
{
try
{
env = globalEnvironments[envName];
}
catch (Exception) { }
}
if (env == null)
{
Console.WriteLine("*** Unknown environment " + envName);
WriteTestCaseElement(testCaseName, "fail", "Environment " + envName + " not found");
failures++;
return;
}
}
}
env.xpathCompiler.BackwardsCompatible = false;
env.processor.XmlVersion = (decimal)1.0;
bool run = true;
bool xpDependency = false;
string hostLang;
string langVersion;
if (preferQuery)
{
hostLang = "XQ";
langVersion = "1.0";
}
else
{
hostLang = "XP";
langVersion = "2.0";
}
XdmValue dependencies = xpc.Evaluate("/*/dependency, ./dependency", testCase);
foreach (XdmItem dependency in dependencies)
{
string type = ((XdmNode)dependency).GetAttributeValue(new QName("type"));
if (type == null)
{
throw new Exception("dependency/@type is missing");
}
string value = ((XdmNode)dependency).GetAttributeValue(new QName("value"));
if (value == null)
{
throw new Exception("dependency/@value is missing");
}
if (type.Equals("spec"))
{
if (value.Contains("XP") && !value.Contains("XQ"))
{
hostLang = "XP";
langVersion = (value.Equals("XP20") ? "2.0" : "3.0");
xpDependency = true;
}
else if (value.Contains("XP") && value.Contains("XQ") && preferQuery)
{
hostLang = "XQ";
langVersion = (value.Contains("XQ10+") || value.Contains("XQ30") ? "3.0" : "1.0");
}
else if (value.Contains("XT"))
{
hostLang = "XT";
langVersion = (value.Contains("XT30+") || value.Contains("XT30") ? "3.0" : "1.0");
}
else
{
hostLang = "XQ";
langVersion = (value.Contains("XQ10+") || value.Contains("XQ30") ? "3.0" : "1.0");
}
}
if (type.Equals("feature") && value.Equals("xpath-1.0-compatibility"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
}
if (type.Equals("feature") && value.Equals("namespace-axis"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
}
if (!DependencyIsSatisfied((XdmNode)dependency, env))
{
Console.WriteLine("*** Dependency not satisfied: " + ((XdmNode)dependency).GetAttributeValue(new QName("type")));
WriteTestCaseElement(testCaseName, "notRun", "Dependency not satisfied");
run = false;
}
}
if ((unfolded && !xpDependency) || optimization != null)
{
hostLang = "XQ";
if (langVersion.Equals("2.0"))
{
langVersion = "1.0";
}
}
if (run)
{
Outcome outcome = null;
string exp = null;
try
{
exp = xpc.Evaluate("if (test/@file) then unparsed-text(resolve-uri(test/@file, base-uri(.))) else string(test)", testCase).ToString();
}
catch (DynamicError err)
{
Console.WriteLine("*** Failed to read query: " + err.Message);
outcome = new Outcome(err);
}
if (outcome == null)
{
if (hostLang.Equals(("XP")))
{
XPathCompiler testXpc = env.xpathCompiler;
testXpc.XPathLanguageVersion = langVersion;
testXpc.DeclareNamespace("fn", JNamespaceConstant.FN);
testXpc.DeclareNamespace("xs", JNamespaceConstant.SCHEMA);
testXpc.DeclareNamespace("math", JNamespaceConstant.MATH);
testXpc.DeclareNamespace("map", JNamespaceConstant.MAP_FUNCTIONS);
try
{
XPathSelector selector = testXpc.Compile(exp).Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetVariable(varName, env.params1[varName]);
}
if (env.contextNode != null)
{
selector.ContextItem = env.contextNode;
}
selector.InputXmlResolver = new TestUriResolver(env);
XdmValue result = selector.Evaluate();
outcome = new Outcome(result);
}
catch (DynamicError err)
{
Console.WriteLine(err.Message);
outcome = new Outcome(err);
}
catch (StaticError err)
{
Console.WriteLine(err.Message);
outcome = new Outcome(err);
}
catch (Exception err)
{
Console.WriteLine("*** Failed to read query: " + err.Message);
outcome = new Outcome(new DynamicError("*** Failed to read query: " + err.Message));
}
}
else
{
XQueryCompiler testXqc = env.xqueryCompiler;
testXqc.XQueryLanguageVersion = langVersion;
testXqc.DeclareNamespace("fn", JNamespaceConstant.FN);
testXqc.DeclareNamespace("xs", JNamespaceConstant.SCHEMA);
testXqc.DeclareNamespace("math", JNamespaceConstant.MATH);
testXqc.DeclareNamespace("map", JNamespaceConstant.MAP_FUNCTIONS);
ErrorCollector errorCollector = new ErrorCollector();
//testXqc.setErrorListener(errorCollector);
string decVars = env.paramDecimalDeclarations.ToString();
if (decVars.Length != 0)
{
int x = (exp.IndexOf("(:%DECL%:)"));
if (x < 0)
{
exp = decVars + exp;
}
else
{
exp = exp.Substring(0, x) + decVars + exp.Substring(x + 13);
}
}
string vars = env.paramDeclarations.ToString();
if (vars.Length != 0)
{
int x = (exp.IndexOf("(:%VARDECL%:)"));
if (x < 0)
{
exp = vars + exp;
}
else
{
exp = exp.Substring(0, x) + vars + exp.Substring(x + 13);
}
}
ModuleResolver mr = new ModuleResolver(xpc);
mr.setTestCase(testCase);
testXqc.QueryResolver = (IQueryResolver)mr;
try
{
XQueryExecutable q = testXqc.Compile(exp);
if (optimization != null)
{
/* XdmDestination expDest = new XdmDestination();
net.sf.saxon.Configuration config = driverProc.Implementation;
net.sf.saxon.trace.ExpressionPresenter presenter = new net.sf.saxon.trace.ExpressionPresenter(driverProc.Implementation, expDest.getReceiver(config));
//q.getUnderlyingCompiledQuery().explain(presenter);
presenter.close();
XdmNode explanation = expDest.XdmNode;
XdmItem optResult = xpc.EvaluateSingle(optimization.GetAttributeValue(new QName("assert")), explanation);
if ((bool)((XdmAtomicValue)optResult).Value)
{
Console.WriteLine("Optimization result OK");
}
else
{
Console.WriteLine("Failed optimization test");
Serializer serializer = new Serializer();
serializer.SetOutputWriter(Console.Error);
driverProc.WriteXdmValue(explanation, serializer);
WriteTestCaseElement(testCaseName, "fail", "Failed optimization assertions");
failures++;
return;
}*/
}
XQueryEvaluator selector = q.Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetExternalVariable(varName, env.params1[varName]);
}
if (env.contextNode != null)
{
selector.ContextItem = env.contextNode;
}
selector.InputXmlResolver= new TestUriResolver(env);
XdmValue result = selector.Evaluate();
outcome = new Outcome(result);
}
catch (DynamicError err)
{
Console.WriteLine("TestSet" + testFuncSet);
Console.WriteLine(err.Message);
outcome = new Outcome(err);
outcome.setErrorsReported(errorCollector.getErrorCodes());
}
catch(StaticError err){
Console.WriteLine("TestSet" + testFuncSet);
Console.WriteLine(err.Message);
outcome = new Outcome(err);
outcome.setErrorsReported(errorCollector.getErrorCodes());
}
catch(Exception err){
Console.WriteLine("TestSet" + testFuncSet);
Console.WriteLine(err.Message);
outcome = new Outcome(new DynamicError(err.Message));
outcome.setErrorsReported(errorCollector.getErrorCodes());
}
}
}
XdmNode assertion;
if (alternativeResult != null)
{
assertion = (XdmNode)xpc.EvaluateSingle("*[1]", alternativeResult);
}
else
{
assertion = (XdmNode)xpc.EvaluateSingle("result/*[1]", testCase);
}
if (assertion == null)
{
Console.WriteLine("*** No assertions found for test case " + testCaseName);
WriteTestCaseElement(testCaseName, "fail", "No assertions in test case");
failures++;
return;
}
XPathCompiler assertXpc = env.processor.NewXPathCompiler();
assertXpc.XPathLanguageVersion = "3.0";
assertXpc.DeclareNamespace("fn", JNamespaceConstant.FN);
assertXpc.DeclareNamespace("xs", JNamespaceConstant.SCHEMA);
assertXpc.DeclareNamespace("math", JNamespaceConstant.MATH);
assertXpc.DeclareNamespace("map", JNamespaceConstant.MAP_FUNCTIONS);
assertXpc.DeclareVariable(new QName("result"));
bool b = testAssertion(assertion, outcome, assertXpc, xpc, debug);
if (b)
{
Console.WriteLine("OK");
successes++;
feedback.Message("OK" + Environment.NewLine, false);
WriteTestCaseElement(testCaseName, "full", null);
}
else
{
if (outcome.isException())
{
XdmItem expectedError = xpc.EvaluateSingle("result//error/@code", testCase);
if (expectedError == null)
{
// if (debug) {
// outcome.getException().printStackTrace(System.out);
// }
if (outcome.getException() is StaticError)
{
WriteTestCaseElement(testCaseName, "fail", "Expected success, got " + ((StaticError)outcome.getException()).ErrorCode);
feedback.Message("*** fail, result " + ((StaticError)outcome.getException()).ErrorCode.LocalName +
" Expected success." + Environment.NewLine, false);
}
else
{
WriteTestCaseElement(testCaseName, "fail", "Expected success, got " + ((DynamicError)outcome.getException()).ErrorCode);
feedback.Message("*** fail, result " + ((DynamicError)outcome.getException()).ErrorCode.LocalName +
" Expected success." + Environment.NewLine, false);
}
failures++;
}
else
{
if (outcome.getException() is StaticError)
{
WriteTestCaseElement(testCaseName, "different-error", "Expected error:" + expectedError.ToString() /*.GetstringValue()*/ + ", got " + ((StaticError)outcome.getException()).ErrorCode.ToString());
feedback.Message("*** fail, result " + ((StaticError)outcome.getException()).ErrorCode.LocalName +
" Expected error:" + expectedError.ToString() + Environment.NewLine, false);
}
else
{
WriteTestCaseElement(testCaseName, "different-error", "Expected error:" + expectedError.ToString() /*.GetstringValue()*/ + ", got " + ((DynamicError)outcome.getException()).ErrorCode.ToString());
feedback.Message("*** fail, result " + ((DynamicError)outcome.getException()).ErrorCode.LocalName +
" Expected error:" + expectedError.ToString() + Environment.NewLine, false);
}
wrongErrorResults++;
}
}
else
{
try
{
WriteTestCaseElement(testCaseName, "fail", "Wrong results, got " + truncate(outcome.serialize(assertXpc.Processor)));
}catch (Exception) {
WriteTestCaseElement(testCaseName, "fail", "Wrong results, got ");
}
failures++;
if (debug)
{
try
{
feedback.Message("Result:" + Environment.NewLine, false);
// driverProc.WriteXdmValue(outcome.getResult(), driverSerializer);
feedback.Message("=======" + Environment.NewLine, false);
}
catch (Exception)
{
}
feedback.Message(outcome.getResult() + Environment.NewLine, false);
}
else
{
feedback.Message("*** fail (use -debug to show actual result)" + Environment.NewLine, false);
}
}
}
feedback.Feedback(successes, failures, 25693);
}
}
private void AssertModuleResolver()
{
if (moduleResolver == null)
{
DirectoryInfo modulesDirectory = null;
if (!string.IsNullOrWhiteSpace(ModulesDirectoryPath))
{
modulesDirectory = new DirectoryInfo(ModulesDirectoryPath);
}
moduleResolver = new ModuleResolver(enabledModules, modulesDirectory);
}
}
public ActionResult CompareResults(string result)
{
ResolveInformation inf = new JavaScriptSerializer().Deserialize <ResolveInformation>(result);
inf.DllFilePath = Server.MapPath("~/Scripts/TestsFolder/" + inf.DllFilePath);
ITransform transform = ModuleResolver.GetTransformDll(inf.DllFilePath, inf.ResolveDllType);
string studentFile = transform.TransformFileFromClient(result);
string studentDirPath = Server.MapPath("~/ProjectsExpressions");
DirectoryInfo projectExpr = new DirectoryInfo(studentDirPath);
DirectoryInfo studentName = new DirectoryInfo(studentDirPath + "/" + User.Identity.Name);
DirectoryInfo testDir = new DirectoryInfo(studentDirPath + "/" + User.Identity.Name + "/" + inf.Description);
if (!projectExpr.GetDirectories().Contains(studentName))
{
studentName.Create();
}
if (studentName.GetDirectories().Contains(testDir))
{
testDir.Delete();
}
testDir.Create();
FileInfo studentFileInfo = new FileInfo(testDir.FullName + "/" + "Input.rgl");
using (StreamWriter writer = new StreamWriter(studentFileInfo.Create()))
{
writer.Write(studentFile);
}
ITestEndpoints testModule = ModuleResolver.GetAppDll(inf.DllFilePath, inf.ResolveDllType);
string gradeResult = testModule.Grade(testDir.FullName);
TestEntity test = testService.GetTestById(inf.Id);
if (gradeResult == "0")
{
string automataFile = transform.TransformFileFromClient2(result);
StringBuilder automataFileSb = new StringBuilder(automataFile);
automataFileSb.AppendLine("Private Partition");
automataFileSb.AppendLine();
FileInfo partitionFile = new FileInfo(testDir + "/" + inf.Description + "/" + inf.Description + "_Partition.txt");
string partition = "";
using (StreamReader reader = partitionFile.OpenText())
{
partition = reader.ReadToEnd();
}
partition = partition.Replace("\n", "");
string[] lines = partition.Split(Environment.NewLine.ToCharArray()).Skip(3).ToArray();
int k = 0;
while (k != lines.Length && lines[k] != "*****")
{
automataFileSb.AppendLine(lines[k++]);
}
automataFileSb.AppendLine("*****");
DirectoryInfo compareDir = testDir.CreateSubdirectory("Automata");
FileInfo studentAnswer = new FileInfo(compareDir.FullName + "/student_file.txt");
using (StreamWriter studentWriter = new StreamWriter(studentAnswer.Create()))
{
studentWriter.Write(automataFileSb.ToString());
}
FileInfo rightAnswer = new FileInfo(compareDir.FullName + "/answer_file.txt");
FileInfo[] files = this.GetTestFiles(inf.Id);
using (FileStream fs = files[inf.TestFileNumber].OpenRead())
{
using (StreamReader sr = new StreamReader(fs))
{
using (FileStream rightAnswerFs = rightAnswer.Create())
{
using (StreamWriter answerWriter = new StreamWriter(rightAnswerFs))
{
answerWriter.Write(sr.ReadToEnd());
}
}
}
}
gradeResult = testModule.Grade(studentAnswer.FullName, rightAnswer.FullName);
if (gradeResult == "True")
{
gradeResult = "0";
}
}
if (gradeResult == "0")
{
gradeResult = "10";
}
else
{
gradeResult = "0";
}
AnswerEntity answerEnt = new AnswerEntity()
{
Content = System.Text.Encoding.Default.GetBytes(result),
Mark = Double.Parse(gradeResult),
TestId = test.Id,
UserId = userService.GetUserByEmail(User.Identity.Name).Id,
TestEndTime = DateTime.Now
};
testService.CreateAnswer(answerEnt);
return(Json(new { Mark = gradeResult }));
}
internal void AddUnresolvedModule(string relativeModuleName, bool absoluteImports)
{
_unresolvedModules.UnionWith(ModuleResolver.ResolvePotentialModuleNames(_projectEntry, relativeModuleName, absoluteImports));
_projectEntry.ProjectState.ModuleHasUnresolvedImports(this, true);
}
/**
* Run a test case
*
*
* @param testCase the test case element in the catalog
* @param xpc the XPath compiler to be used for compiling XPath expressions against the catalog
* @
*/
protected override void runTestCase(XdmNode testCase, XPathCompiler xpc)
{
bool run = true;
bool xpDependency = false;
string hostLang;
string langVersion;
Spec specOpt = Spec.NULL;
XPathCompiler xpath = driverProc.NewXPathCompiler();
string testCaseName = testCase.GetAttributeValue(new QName("name"));
string testSetName = testCase.Parent.GetAttributeValue(new QName("name"));
bool needSerializedResult = ((XdmAtomicValue)xpc.EvaluateSingle(
"exists(./result//assert-serialization-error) or exists(./result//serialization-matches)", testCase)).GetBooleanValue();
bool needResultValue = true;
if (needSerializedResult)
{
needResultValue = ((XdmAtomicValue)xpc.EvaluateSingle(
"exists(./result//*[not(self::serialization-matches or self::assert-serialization-error or self::any-of or self::all-of)])", testCase)).GetBooleanValue();
}
XdmNode alternativeResult = null;
XdmNode optimization = null;
hostLang = ((SpecAttr)spec.GetAttr()).sname;
langVersion = ((SpecAttr)spec.GetAttr()).version;
Environment env = getEnvironment(testCase, xpc);
if (env == null)
{
notrun++;
return;
}
env.xpathCompiler.BackwardsCompatible = false;
env.processor.XmlVersion = (decimal)1.0;
//test
bool icuColCheck = net.sf.saxon.Version.platform.hasICUCollator();
bool icuNumCheck = net.sf.saxon.Version.platform.hasICUNumberer();
Console.WriteLine("ICUCol: " + (icuColCheck ? "true" : "false"));
Console.WriteLine("ICUNum: " + (icuNumCheck ? "true" : "false"));
//end of test
foreach (XdmItem dependency in xpc.Evaluate("/*/dependency, ./dependency", testCase))
{
string type = ((XdmNode)dependency).GetAttributeValue(new QName("type"));
if (type == null)
{
// throw new IllegalStateException("dependency/@type is missing"); //TODO
}
string value = ((XdmNode)dependency).GetAttributeValue(new QName("value"));
if (value == null)
{
//throw new IllegalStateException("dependency/@value is missing"); //TODO
}
if (type.Equals("spec"))
{
bool applicable = false;
if (!value.Contains(((SpecAttr)spec.GetAttr()).sname))
{
applicable = false;
}
else if (value.Contains(((SpecAttr)spec.GetAttr()).svname))
{
applicable = true;
}
else if (((SpecAttr)spec.GetAttr()).svname.Equals("XQ30") && value.Contains("XQ10+"))
{
applicable = true;
}
else if (((SpecAttr)spec.GetAttr()).svname.Equals("XP30") && value.Contains("XP20+"))
{
applicable = true;
}
if (!applicable)
{
writeTestcaseElement(testCaseName, "n/a", "not" + ((SpecAttr)spec.GetAttr()).svname, spec);
notrun++;
return;
}
}
if (langVersion.Equals("3.0"))
{
/* EnvironmentVariableResolver resolver = new EnvironmentVariableResolver() {
* public Set<string> getAvailableEnvironmentVariables() {
* Set<string> strings = new HashSet<string>();
* strings.add("QTTEST");
* strings.add("QTTEST2");
* strings.add("QTTESTEMPTY");
* return strings;
* }
*
* public string getEnvironmentVariable(string name) {
* if (name.Equals("QTTEST")) {
* return "42";
* } else if (name.Equals("QTTEST2")) {
* return "other";
* } else if (name.Equals("QTTESTEMPTY")) {
* return "";
* } else {
* return null;
* }
* }
* }; */
//TODO
//env.processor.SetProperty(JFeatureKeys.ENVIRONMENT_VARIABLE_RESOLVER, resolver);
}
if (type.Equals("feature") && value.Equals("xpath-1.0-compatibility"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
specOpt = Spec.XP30;
}
if (type.Equals("feature") && value.Equals("namespace-axis"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
specOpt = Spec.XP30;
}
if (!dependencyIsSatisfied((XdmNode)dependency, env))
{
println("*** Dependency not satisfied: " + ((XdmNode)dependency).GetAttributeValue(new QName("type")));
writeTestcaseElement(testCaseName, "n/a", "Dependency not satisfied", spec);
run = false;
notrun++;
return;
}
}
XdmNode exceptionElement;
try{
exceptionElement = exceptionsMap[testCaseName];
} catch (Exception) {
exceptionElement = null;
}
if (exceptionElement != null)
{
XdmItem config = xpath.EvaluateSingle("configuration", exceptionElement);
string runAtt = exceptionElement.GetAttributeValue(new QName("run"));
string reasonMsg = xpath.EvaluateSingle("reason", exceptionElement).ToString();
string reportAtt = exceptionElement.GetAttributeValue(new QName("report"));
if (config != null)
{
XdmItem paramValue = xpath.EvaluateSingle("param[@name='not-unfolded' and @value='yes']/@name", config);
if (unfolded && paramValue != null)
{
writeTestcaseElement(testCaseName, "notRun", reasonMsg, spec);
notrun++;
return;
}
}
if ("false".Equals(runAtt))
{
writeTestcaseElement(testCaseName, reportAtt, reasonMsg, spec);
notrun++;
return;
}
alternativeResult = (XdmNode)xpc.EvaluateSingle("result", exceptionElement);
optimization = (XdmNode)xpc.EvaluateSingle("optimization", exceptionElement);
}
if (run && (specOpt == Spec.NULL || specOpt == spec))
{
TestOutcome outcome = new TestOutcome(this);
string exp = null;
try
{
exp = xpc.Evaluate("if (test/@file) then unparsed-text(resolve-uri(test/@file, base-uri(.))) else string(test)", testCase).ToString();
}
catch (Exception err)
{
println("*** Failed to read query: " + err.Message);
outcome.SetException((DynamicError)err);
}
//noinspection ThrowableResultOfMethodCallIgnored
if (outcome.GetException() == null)
{
if (hostLang.Equals("XP") || hostLang.Equals("XT"))
{
XPathCompiler testXpc = env.xpathCompiler;
testXpc.XPathLanguageVersion = langVersion;
testXpc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
testXpc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
testXpc.DeclareNamespace("map", "http://www.w3.org/2005/xpath-functions/map");
//testXpc.DeclareNamespace("math", NamespaceConstant.MATH);
//testXpc.DeclareNamespace("Dictionary", NamespaceConstant.Dictionary_FUNCTIONS);
try
{
XPathSelector selector = testXpc.Compile(exp).Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetVariable(varName, env.params1[varName]);
}
if (env.contextItem != null)
{
selector.ContextItem = env.contextItem;
}
selector.InputXmlResolver = new TestUriResolver(env);
if (env.unparsedTextResolver != null)
{
//selector.getUnderlyingXPathContext().setUnparsedTextURIResolver(env.unparsedTextResolver); //TODO
}
XdmValue result = selector.Evaluate();
outcome.SetPrincipalResult(result);
}
catch (Exception err)
{
println(err.Message);
outcome.SetException(err);
}
}
else if (hostLang.Equals("XQ"))
{
XQueryCompiler testXqc = env.xqueryCompiler;
testXqc.XQueryLanguageVersion = langVersion;
testXqc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
testXqc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
//testXqc.DeclareNamespace("math", NamespaceConstant.MATH);
testXqc.DeclareNamespace("map", "http://www.w3.org/2005/xpath-functions/map");
// ErrorCollector errorCollector = new ErrorCollector();
testXqc.ErrorList = new ArrayList();
string decVars = env.paramDecimalDeclarations.ToString();
if (decVars.Length != 0)
{
int x = (exp.IndexOf("(:%DECL%:)"));
if (x < 0)
{
exp = decVars + exp;
}
else
{
exp = exp.Substring(0, x) + decVars + exp.Substring(x + 13);
}
}
string vars = env.paramDeclarations.ToString();
if (vars.Length != 0)
{
int x = (exp.IndexOf("(:%VARDECL%:)"));
if (x < 0)
{
exp = vars + exp;
}
else
{
exp = exp.Substring(0, x) + vars + exp.Substring(x + 13);
}
}
ModuleResolver mr = new ModuleResolver(xpc);
mr.setTestCase(testCase);
// testXqc.QueryResolver = mr;// .setModuleURIResolver(mr); //TODO
testXqc.QueryResolver = mr;
try
{
XQueryExecutable q = testXqc.Compile(exp);
if (optimization != null)
{
// Test whether required optimizations have been performed
XdmDestination expDest = new XdmDestination();
JConfiguration config = driverProc.Implementation;
//ExpressionPresenter presenter = new ExpressionPresenter(config, expDest.getReceiver(config));
//q.getUnderlyingCompiledQuery().explain(presenter);
//presenter.close();
XdmNode explanation = expDest.XdmNode;
XdmItem optResult = xpc.EvaluateSingle(optimization.GetAttributeValue(new QName("assert")), explanation);
if (((XdmAtomicValue)optResult).GetBooleanValue())
{
println("Optimization result OK");
}
else
{
println("Failed optimization test");
Serializer ser = new Serializer();
ser.SetOutputStream((Stream)System.Console.OpenStandardError());
driverProc.WriteXdmValue(explanation, ser);
writeTestcaseElement(testCaseName, "fail", "Failed optimization assertions", spec);
failures++;
return;
}
}
XQueryEvaluator selector = q.Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetExternalVariable(varName, env.params1[varName]);
}
if (env.contextItem != null)
{
selector.ContextItem = env.contextItem;
}
selector.InputXmlResolver = env;
//selector.InputXmlResolver = .SetURIResolver(new TestURIResolver(env)); //TODO
if (env.unparsedTextResolver != null)
{
selector.Implementation.setUnparsedTextURIResolver(env.unparsedTextResolver);// TODO
}
if (needSerializedResult)
{
StringWriter sw = new StringWriter();
Serializer serializer = new Serializer(); //env.processor.NewSerializer(sw); //TODO
serializer.SetOutputWriter(sw);
selector.Run(serializer);
outcome.SetPrincipalSerializedResult(sw.ToString());
}
if (needResultValue)
{
XdmValue result = selector.Evaluate();
outcome.SetPrincipalResult(result);
}
}
catch (Exception err)
{
println("in TestSet " + testSetName + err.StackTrace);
println(err.Message);
outcome.SetException(err);
outcome.SetErrorsReported((IList)testXqc.ErrorList);
}
}
else
{
writeTestcaseElement(testCaseName, "notRun", "No processor found", spec);
notrun++;
return;
}
}
if (env.resetAction != null)
{
env.resetAction.reset(env);
}
XdmNode assertion;
if (alternativeResult != null)
{
assertion = (XdmNode)xpc.EvaluateSingle("*[1]", alternativeResult);
}
else
{
assertion = (XdmNode)xpc.EvaluateSingle("result/*[1]", testCase);
}
if (assertion == null)
{
println("*** No assertions found for test case " + testCaseName);
writeTestcaseElement(testCaseName, "disputed", "No assertions in test case", spec);
feedback.Feedback(successes, failures++, total);
return;
}
XPathCompiler assertXpc = env.processor.NewXPathCompiler();
assertXpc.XPathLanguageVersion = "3.1";
assertXpc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
assertXpc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
assertXpc.DeclareNamespace("math", "http://www.w3.org/2005/xpath-functions/math");
assertXpc.DeclareNamespace("MAP_FUNCTIONS", "http://www.w3.org/2005/xpath-functions/map");
assertXpc.DeclareVariable(new QName("result"));
bool b = outcome.TestAssertion(assertion, outcome.GetPrincipalResultDoc(), assertXpc, xpc, debug);
if (b)
{
//println("OK");
writeTestcaseElement(testCaseName, "pass", null, spec);
feedback.Feedback(successes++, failures, total);
}
else
{
if (outcome.IsException())
{
XdmItem expectedError = xpc.EvaluateSingle("result//error/@code", testCase);
if (expectedError == null)
{
// if (debug) {
// outcome.getException().printStackTrace(System.out);
// }
writeTestcaseElement(testCaseName, "fail", "Expected success, got ", spec);
println("*** fail, result " + outcome.GetException() +
" Expected success.");
feedback.Feedback(successes, failures++, total);
}
else
{
writeTestcaseElement(testCaseName, "wrongError",
"Expected error:" + expectedError.ToString() + ", got " + outcome.GetErrorCode().LocalName, spec);
println("*** fail, result " + outcome.GetErrorCode().LocalName +
" Expected error:" + expectedError.ToString());
wrongErrorResults++;
feedback.Feedback(successes++, failures, total);
}
}
else
{
writeTestcaseElement(testCaseName, "fail", "Wrong results, got " +
truncate(outcome.Serialize(assertXpc.Processor, outcome.GetPrincipalResultDoc())), spec);
feedback.Feedback(successes, failures++, total);
if (debug)
{
try
{
println("Result:");
driverProc.WriteXdmValue(outcome.GetPrincipalResult(), driverSerializer);
println("<=======");
}
catch (Exception err)
{
}
//println(outcome.getResult());
}
else
{
println("*** fail (use -debug to show actual result)");
//failures++;
}
}
}
}
}
