public void Conditional_Is_Visible_With_True(string condition) { var target = new VariableResolver(new List <Variable>()); var result = target.TransformVariables("Hello\n<!--[if " + condition + "]-->\ntobi!\n<!--[endif]-->"); Assert.AreEqual("Hello\r\ntobi!", result); }
public void Multiple_Conditional_Transforming(string condition1, string condition2, string assert) { var variableList = new List <Variable>() { new Variable() { Name = "true.condition", Value = "true" }, new Variable() { Name = "false.condition", Value = "false" }, }; var target = new VariableResolver(variableList); var result = target.TransformVariables("<!-- [if " + condition1 + "] -->" + System.Environment.NewLine + "content 1" + System.Environment.NewLine + "<!-- [endif] -->" + System.Environment.NewLine + "<!-- [if " + condition2 + "] -->" + System.Environment.NewLine + "content 2" + System.Environment.NewLine + "<!-- [endif] -->"); Assert.AreEqual(assert, result); }
private TaintSets Node_FuncCall(XmlNode node) { if (!isConditional) { return(null); } // We use the True scope as both True and False are the same at this point in time var functionCallExtractor = new FunctionCallExtractor(); var functionCall = functionCallExtractor.ExtractFunctionCall(node); var condSaniFunc = _funcHandler.FindCondSanitizerByName(functionCall.Name); if (condSaniFunc != null) { var parameter = functionCall.Arguments; var varResolverFalse = new VariableResolver(_variables[EdgeType.False]); if (parameter.Any(x => varResolverFalse.IsResolvableNode(x.Value)) && condSaniFunc.DefaultStatus == MixedStatus.XSSSQL_SAFE) { if (isNegated) { var var = varResolverFalse.ResolveVariable(parameter.First(x => varResolverFalse.IsResolvableNode(x.Value)).Value); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } else { var varResolverTrue = new VariableResolver(_variables[EdgeType.True]); var var = varResolverTrue.ResolveVariable(parameter.First(x => varResolverTrue.IsResolvableNode(x.Value)).Value); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } } } return(new TaintSets().ClearTaint()); }
public void Dont_Resolve_Escaped_Variable() { var target = new VariableResolver(new List <Variable>()); var result = target.TransformVariables("Hello _$_{Escaped}!"); Assert.AreEqual("Hello ${Escaped}!", result); }
public void Conditional_Not_Visible_With_False_Negated(string condition) { var target = new VariableResolver(new List <Variable>()); var result = target.TransformVariables("Hello\n<!--[if not " + condition + "]-->\ntobi!\n<!--[endif]-->"); Assert.AreEqual("Hello", result); }
public void List_Multiple_Missing_Variables_Test() { var target = new VariableResolver(new List <Variable>()); target.TransformVariables("${a} ${b} ${c}"); Assert.AreEqual(3, target.VariableUsageList.Count(v => v.IsMissingValue)); }
public void Resolve_Using_Default_Value_Test() { var variableList = new List <Variable>(); var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello ${FirstName=Mila} ${LastName=Kunis}!"); Assert.AreEqual("Hello Mila Kunis!", result); }
public void SetUp() { dynamic variables = new ExpandoObject(); variables.scalarIntVariable = "1"; this.intNamedType = GetIntNamedType(); this.schemaRepository = Substitute.For <ISchemaRepository>(); this.variableResolver = new VariableResolver(variables, this.schemaRepository, this.GetVariableDefinitions()); }
public void SetUp() { dynamic variables = new ExpandoObject(); variables.scalarIntVariable = "1"; this.intNamedType = GetIntNamedType(); this.typeTranslator = Substitute.For <ITypeTranslator>(); this.variableResolver = new VariableResolver(variables, this.typeTranslator, this.GetVariableDefinitions()); }
private EnvironmentVariablesDto GetEnvironment(string name, bool fetchVariables) { using (var session = DocumentStore.OpenSession()) { var environment = session.Query <Environment>().FirstOrDefault(e => e.Name == name); if (environment == null) { throw HttpError.NotFound("Environment {0} not found.".Fmt(name)); } using (var workspace = new Workspace(FileSystem, ServerSettings)) { var result = new EnvironmentVariablesDto() { Environment = environment.ToDto() }; if (fetchVariables) { workspace.UpdateSources(); var provider = new EnvironmentProvider(); try { var serializedEnvironment = provider.GetEnvironmentFromFile(Path.Combine(workspace.EnviornmentPath, name + ".xml")); var resolver = new VariableResolver(serializedEnvironment.Variables); result.Variables = new List <VariableDto>(); result.Variables.AddRange(serializedEnvironment.Variables.Select(v => new VariableDto() { Name = v.Name, Value = v.Value, Resolved = resolver.TransformVariables(v.Value) })); if (resolver.VariableUsageList.Any(v => v.IsMissingValue)) { result.MissingVariables = new List <string>(resolver.VariableUsageList.Where(v => v.IsMissingValue).Select(v => v.Variable.Name)); } } catch (FileNotFoundException e) { result.Variables = new List <VariableDto>(); result.Warning = "No xml file found for this environment!"; } } return(result); } } }
public ImmutableVariableStorage Analyze(XmlNode node, ImmutableVariableStorage knownTaint) { Preconditions.NotNull(knownTaint, "knownTaint"); _variableStorage = knownTaint.ToMutable(); _varResolver = new VariableResolver(_variableStorage, _analysisScope); Analyze(node); return ImmutableVariableStorage.CreateFromMutable(_variableStorage); }
[Ignore] // TODO: add warning also for default values public void Resolve_Default_Value_With_Missing_Variable_Test() { var variableList = new List <Variable>() { new Variable() { Name = "FirstName", Value = "Jack" } }; var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello ${FullName=$[gugus]}"); Assert.AreEqual(1, target.VariableUsageList.Count(vu => vu.IsMissingValue)); }
public void Resolve_One_Variable_Test() { var variableList = new List <Variable>() { new Variable() { Name = "Var1", Value = "Jack Bauer" } }; var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello ${Var1}!"); Assert.AreEqual("Hello Jack Bauer!", result); }
public void Conditional_Is_Visible_With_False_Variable_Negated(string condition) { var variableList = new List <Variable>() { new Variable() { Name = "condition", Value = condition } }; var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello\r\n<!--[if not ${condition}]-->\r\ntobi!\r\n<!--[endif]-->"); Assert.AreEqual("Hello", result); }
public void List_Missing_Variables_Test() { var variableList = new List <Variable>() { new Variable() { Name = "FirstName", Value = "Jack" }, }; var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello ${FirstName} ${LastName}!"); Assert.AreEqual(1, target.VariableUsageList.Count(v => v.IsMissingValue)); Assert.AreEqual("Hello Jack !!Missing variable for LastName!!!", result); }
public IImmutableDictionary<EdgeType, ImmutableVariableStorage> AnalyzeCond(XmlNode node, ImmutableVariableStorage knownTaint) { Preconditions.NotNull(knownTaint, "knownTaint"); _variables.Remove(EdgeType.Normal); _variables.Add(EdgeType.Normal, knownTaint.ToMutable()); _varResolver = new VariableResolver(_variables[EdgeType.Normal], _analysisScope); _variables.Remove(EdgeType.False); _variables.Remove(EdgeType.True); Analyze(node); isConditional = false; var variablestore = _variables.Keys.ToDictionary(edgetype => edgetype, edgetype => ImmutableVariableStorage.CreateFromMutable(_variables[edgetype])); return ImmutableDictionary<EdgeType, ImmutableVariableStorage>.Empty.AddRange(variablestore); }
public void ResolveMultipleArrayElements(string phpCode) { XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling; var xmlNodes = ast.FirstChild.Cast <XmlNode>().ToList(); var varNodes = xmlNodes.Where(node => node.LocalName == AstConstants.Nodes.Expr_ArrayDimFetch); var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File); var firstVar = varNodes.First(); var result = varResolver.ResolveVariable(firstVar); result = varResolver.ResolveVariable(firstVar); Assert.IsFalse(result.IsNew, "Var"); result = varResolver.ResolveVariable(varNodes.ElementAt(1)); Assert.IsTrue(result.IsNew, "First lookup of second var"); }
public IImmutableDictionary <EdgeType, ImmutableVariableStorage> AnalyzeCond(XmlNode node, ImmutableVariableStorage knownTaint) { Preconditions.NotNull(knownTaint, "knownTaint"); _variables.Remove(EdgeType.Normal); _variables.Add(EdgeType.Normal, knownTaint.ToMutable()); _varResolver = new VariableResolver(_variables[EdgeType.Normal], _analysisScope); _variables.Remove(EdgeType.False); _variables.Remove(EdgeType.True); Analyze(node); isConditional = false; var variablestore = _variables.Keys.ToDictionary(edgetype => edgetype, edgetype => ImmutableVariableStorage.CreateFromMutable(_variables[edgetype])); return(ImmutableDictionary <EdgeType, ImmutableVariableStorage> .Empty.AddRange(variablestore)); }
public void ResolveStaticPropertyFetch(string phpCode, string expectedVarName, string nodeType) { XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling; var xmlNodes = ast.FirstChild.Cast <XmlNode>() .Where(node => node.LocalName == nodeType); var propFetch = xmlNodes.First(); var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File); var result = varResolver.ResolveVariable(propFetch); Assert.AreEqual(expectedVarName, result.Variable.Name, "Name should match"); Assert.IsTrue(result.IsNew, "New var"); result = varResolver.ResolveVariable(propFetch); Assert.AreEqual(expectedVarName, result.Variable.Name, "Names should still match"); Assert.IsFalse(result.IsNew, "Variable is no longer new"); }
public void ResolveArrayElement(string phpCode, string varName) { XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling; var xmlNodes = ast.FirstChild.Cast <XmlNode>().ToList(); var varNodes = xmlNodes.Where(node => node.LocalName == AstConstants.Nodes.Expr_ArrayDimFetch); var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File); foreach (var varNode in varNodes) { var result = varResolver.ResolveVariable(varNode); Assert.AreEqual(varName, result.Variable.Name, "Names should match"); Assert.IsTrue(result.IsNew, "Variable should be new"); result = varResolver.ResolveVariable(varNode); Assert.AreEqual(varName, result.Variable.Name, "Names should still match"); Assert.IsFalse(result.IsNew, "Variable is no longer new"); } }
public void Resolve_With_Default_Value_Set_Test() { var variableList = new List <Variable>() { new Variable() { Name = "FirstName", Value = "Jack" }, new Variable() { Name = "LastName", Value = "Bauer" }, }; var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello ${FirstName=Mila} ${LastName=Kunis}!"); Assert.AreEqual("Hello Jack Bauer!", result); }
private TaintSets EqualsComparison(XmlNode node) { if (!isConditional) { return(null); } var leftNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Left) .GetSubNodesByPrefix(AstConstants.Node).Single(); var rightNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Right) .GetSubNodesByPrefix(AstConstants.Node).Single(); var scalarNodes = new[] { AstConstants.Nodes.Scalar_DNumber, AstConstants.Nodes.Scalar_LNumber, AstConstants.Nodes.Scalar_MagicConst_Class, AstConstants.Nodes.Scalar_MagicConst_Dir, AstConstants.Nodes.Scalar_MagicConst_File, AstConstants.Nodes.Scalar_MagicConst_Function, AstConstants.Nodes.Scalar_MagicConst_Line, AstConstants.Nodes.Scalar_MagicConst_Method, AstConstants.Nodes.Scalar_MagicConst_Namespace, AstConstants.Nodes.Scalar_MagicConst_Trait, AstConstants.Nodes.Scalar_String, }; if (_varResolver.IsResolvableNode(leftNode) && scalarNodes.Contains(rightNode.LocalName)) { var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]); var var = varResolver.ResolveVariable(leftNode); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } else if (scalarNodes.Contains(leftNode.LocalName) && _varResolver.IsResolvableNode(rightNode)) { var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]); var var = varResolver.ResolveVariable(rightNode); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } return(new TaintSets().ClearTaint()); }
public void ResolveArrayElementMixIndexType() { string phpCode = @"<?php $a['1']; $a[1];"; XmlNode ast = PHPParseUtils.ParsePHPCode(phpCode, Config.PHPSettings.PHPParserPath).FirstChild.NextSibling; var xmlNodes = ast.FirstChild.Cast <XmlNode>().ToList(); var varNodes = xmlNodes.Where(node => node.LocalName == AstConstants.Nodes.Expr_ArrayDimFetch); var varResolver = new VariableResolver(new VariableStorage(), AnalysisScope.File); var arrayfetch = varNodes.First(); var result = varResolver.ResolveVariable(arrayfetch); Assert.AreEqual("1", result.Variable.Name, "Names should match"); Assert.IsTrue(result.IsNew, "Variable should be new"); result = varResolver.ResolveVariable(varNodes.ElementAt(1)); Assert.AreEqual("1", result.Variable.Name, "Names should still match"); Assert.IsFalse(result.IsNew, "Variable is no longer new"); }
private static EvaluatorState Evaluate(string statement, string prompt) { Console.WriteLine(); if (string.IsNullOrWhiteSpace(statement)) { return(null); } VariableResolver resolver = new VariableResolver(); var tokens = tokenizer.Tokenize(statement); var ast = parser.Parse(tokens); var variables = resolver.Resolve(ast); foreach (var resolved in variables) { var nestedPrompt = $"{resolved.Key} = "; var stmt = ProcessKeyEvents(nestedPrompt); var value = Evaluate(stmt, nestedPrompt); printer.Print(new Run() { Text = " --------", Color = RunColor.White }); var existing = variables[resolved.Key]; existing.IsSigned = value.IsSigned; existing.Type = value.Type; existing.Value = value.Value; } var result = evaluator.Evaluate(ast, variables, printer, context); return(result); }
private static void CreatePiscesDatabaseWithModsimNodeNames( TimeSeriesDatabase dbVic, DataTable correlation, string period, string scenario = "") { string fn = period + scenario + ".pdb"; if (File.Exists(fn)) { Console.WriteLine("Warning: Overwriting existing file " + fn); File.Delete(fn); } else { Console.WriteLine("creating " + fn); } SQLiteServer svr = new SQLiteServer(fn); TimeSeriesDatabase db = new TimeSeriesDatabase(svr); VariableResolver vr = new VariableResolver(dbVic, LookupOption.SeriesName); Console.WriteLine("-------------------------------"); Console.WriteLine("database records"); Console.WriteLine("Series saved"); Console.WriteLine("-------------------------------"); for (int i = 0; i < correlation.Rows.Count; i++) { var gain = correlation.Rows[i]["ModsimGain"].ToString(); var neg = correlation.Rows[i]["ModsimNeg"].ToString(); var equation = correlation.Rows[i]["Equation"].ToString().Trim(); if (equation != "") { equation = IncludeScenarioAndPeriod(equation, period, scenario); AddSeries(period, scenario, db, vr, gain, equation, ModsimType.Gain); AddSeries(period, scenario, db, vr, neg, equation, ModsimType.Negative); } } }
public void Resolve_On_Multiple_Lines_Test() { var variableList = new List <Variable>() { new Variable() { Name = "FirstName", Value = "Jack" }, new Variable() { Name = "LastName", Value = "Bauer" }, new Variable() { Name = "SecondLine", Value = "2" }, }; var target = new VariableResolver(variableList); var result = target.TransformVariables(@"Hello ${FirstName} ${LastName}!\r\nThis is another line:${SecondLine}"); Assert.AreEqual(@"Hello Jack Bauer!\r\nThis is another line:2", result); }
public void Resolve_Variable_In_Variable_In_Variable_Test() { var variableList = new List <Variable>() { new Variable() { Name = "A", Value = "A + ${B}" }, new Variable() { Name = "B", Value = "B + ${C}" }, new Variable() { Name = "C", Value = "C" }, }; var target = new VariableResolver(variableList); var result = target.TransformVariables("${A}"); Assert.AreEqual("A + B + C", result); }
public void Resolve_Variable_In_Variable_Test() { var variableList = new List <Variable>() { new Variable() { Name = "FirstName", Value = "Mila" }, new Variable() { Name = "LastName", Value = "Kunis" }, new Variable() { Name = "Fullname", Value = "${FirstName} ${LastName}" }, }; var target = new VariableResolver(variableList); var result = target.TransformVariables("Hello ${Fullname}!"); Assert.AreEqual("Hello Mila Kunis!", result); }
private static void AddSeries(string period, string scenario, TimeSeriesDatabase db, VariableResolver vr, string name, string equation, ModsimType mType) { if (name.Trim().ToLower() == "nan") { return; } if (name.Trim() == "") { Console.WriteLine("--- WARNING modsim Node Name is missing. Type = " + mType.ToString()); return; } CalculationSeries cs = new CalculationSeries(name); cs.TimeInterval = TimeInterval.Monthly; if (mType == ModsimType.Gain) { cs.Expression = string.Format("Max({0}, 0)", equation); } if (mType == ModsimType.Negative) { cs.Expression = string.Format("Abs(Min({0}, 0))", equation); } cs.TimeSeriesDatabase = db; cs.Parser.VariableResolver = vr; cs.Units = "cfs"; db.AddSeries(cs); // add series before calcualte to get an id assigned. cs.Calculate(); // Calculate also saves the data. SetSeriesDatesToBeginningOfMonth(cs); ConsolePrintSeriesNameAndCount(cs); }
public static string ResolveValue(this TestCaseContext testCaseContext, string value) { return(VariableResolver.Resolve(value, item => testCaseContext.GetRequiredItem(item))); }
public void ResolveFuncThrows(string value) { Assert.That(() => VariableResolver.Resolve(value, (key) => throw new KeyNotFoundException()), Throws.InstanceOf <KeyNotFoundException>()); }
public void ResolveThrows(string value) { Assert.That(() => VariableResolver.Resolve(value, (key) => _variables[key]), Throws.InstanceOf <ArgumentException>()); }
private TaintSets Node_FuncCall(XmlNode node) { if (!isConditional) { return null; } // We use the True scope as both True and False are the same at this point in time var functionCallExtractor = new FunctionCallExtractor(); var functionCall = functionCallExtractor.ExtractFunctionCall(node); FunctionsHandler fh = FunctionsHandler.Instance; var condSaniFunc = fh.FindCondSanitizerByName(functionCall.Name); if (condSaniFunc != null) { var parameter = functionCall.Arguments; var varResolverFalse = new VariableResolver(_variables[EdgeType.False]); if (parameter.Any(x => varResolverFalse.IsResolvableNode(x.Value)) && condSaniFunc.DefaultStatus == MixedStatus.XSSSQL_SAFE) { if (isNegated) { var var = varResolverFalse.ResolveVariable(parameter.First(x => varResolverFalse.IsResolvableNode(x.Value)).Value); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } else { var varResolverTrue = new VariableResolver(_variables[EdgeType.True]); var var = varResolverTrue.ResolveVariable(parameter.First(x => varResolverTrue.IsResolvableNode(x.Value)).Value); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } } } return new TaintSets().ClearTaint(); }
private TaintSets EqualsComparison(XmlNode node) { if (!isConditional) { return null; } var leftNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Left) .GetSubNodesByPrefix(AstConstants.Node).Single(); var rightNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Right) .GetSubNodesByPrefix(AstConstants.Node).Single(); var scalarNodes = new[] { AstConstants.Nodes.Scalar_DNumber, AstConstants.Nodes.Scalar_LNumber, AstConstants.Nodes.Scalar_MagicConst_Class, AstConstants.Nodes.Scalar_MagicConst_Dir, AstConstants.Nodes.Scalar_MagicConst_File, AstConstants.Nodes.Scalar_MagicConst_Function, AstConstants.Nodes.Scalar_MagicConst_Line, AstConstants.Nodes.Scalar_MagicConst_Method, AstConstants.Nodes.Scalar_MagicConst_Namespace, AstConstants.Nodes.Scalar_MagicConst_Trait, AstConstants.Nodes.Scalar_String, }; if (_varResolver.IsResolvableNode(leftNode) && scalarNodes.Contains(rightNode.LocalName)) { var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]); var var = varResolver.ResolveVariable(leftNode); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } else if (scalarNodes.Contains(leftNode.LocalName) && _varResolver.IsResolvableNode(rightNode)) { var varResolver = new VariableResolver(_variables[isNegated ? EdgeType.False : EdgeType.True]); var var = varResolver.ResolveVariable(rightNode); var.Variable.Info.Taints = new TaintSets().ClearTaint(); } return new TaintSets().ClearTaint(); }
private ExpressionInfo Expr_Ternary(XmlNode node) { var condNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Cond); var ifTrueNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.If); var ifFalseNode = node.GetSubNode(AstConstants.Subnode + ":" + AstConstants.Subnodes.Else); Analyze(condNode); var condAnalyzer = new ConditionTaintAnalyser(_analysisScope, this._inclusionResolver, _analysisStacks.IncludeStack); var condResult = condAnalyzer.AnalyzeCond(condNode, ImmutableVariableStorage.CreateFromMutable(_variableStorage)); var currentResolver = this._varResolver; this._varResolver = new VariableResolver(condResult[EdgeType.True].ToMutable()); var leftTaint = Analyze(ifTrueNode); this._varResolver = new VariableResolver(condResult[EdgeType.False].ToMutable()); var rightTaint = Analyze(ifFalseNode); this._varResolver = currentResolver; return leftTaint.Merge(rightTaint); }
public SeriesExpressionParser() { // default resolver requires adding variables in advance m_variableResolver = new VariableResolver(); m_VariableParser = new VariableParser(); }
Types tokType; // holds token's type #endregion Fields #region Constructors public SeriesExpressionParser(TimeSeriesDatabase db,LookupOption lookup= LookupOption.SeriesName) { m_db = db; m_variableResolver = new VariableResolver(db, lookup); m_VariableParser = new VariableParser(); }