public void Empty() { var configuration = new ConfigurationBuilder().Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders("", configuration); Assert.Empty(value); }
private void AddBoundVariablesForRemainingVars() { var remainingVars = NotEliminatedVars.Except(IntermediateFrameWithWitnesses); existsVarMap = remainingVars.ToDictionary(v => (Variable)VarHelper.BoundVariable(v.Name, v.TypedIdent.Type)); pathExprs = SubstitutionHelper.Apply(existsVarMap, pathExprs).ToList(); }
private void ReplacePreOrPostStateVars() { var sub = new Dictionary <Variable, Expr>(); foreach (var v in trc.allInParams) { sub[varCopies[v][0]] = Expr.Ident(v); } foreach (var v in trc.frame) { sub[varCopies[v][0]] = ExprHelper.Old(Expr.Ident(v)); } if (!trc.ignorePostState) { foreach (var v in trc.PostStateVars) { var lastCopy = varCopies[v].Last(); if (sub.ContainsKey(lastCopy)) { Debug.Assert(trc.frame.Contains(v) && lastCopy == varCopies[v][0]); pathExprs.Add(Expr.Eq(Expr.Ident(v), sub[lastCopy])); } // In case of conflict we prefer "v" instead of "old(v)" sub[lastCopy] = Expr.Ident(v); } } pathExprs = SubstitutionHelper.Apply(sub, pathExprs).ToList(); }
public void Null() { var configuration = new ConfigurationBuilder().Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders(null, configuration); Assert.Null(value); }
public void MultipleNonExistent() { var configuration = new ConfigurationBuilder().Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders("Server=.;Database=Local.Database;User ID=${Database:User};Password=${Database:Password}", configuration); Assert.Equal("Server=.;Database=Local.Database;User ID=${Database:User};Password=${Database:Password}", value); }
public void BasicNonExistent() { var configuration = new ConfigurationBuilder().Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders("${prefixed:DoesNotExist}", configuration); Assert.Equal("${prefixed:DoesNotExist}", value); }
private void TryElimination(IEnumerable <Variable> extraDefinedVariables) { bool Defined(Variable v) => varToExpr.ContainsKey(v) || extraDefinedVariables.Contains(v); bool changed; do { changed = false; var remainingAssignments = new List <Assignment>(); foreach (var assignment in assignments) { if (!Defined(assignment.Var) && VariableCollector.Collect(assignment.Expr). Intersect(AllIntroducedVariables).All(Defined)) { varToExpr[assignment.Var] = SubstitutionHelper.Apply(varToExpr, assignment.Expr); changed = true; } else { remainingAssignments.Add(assignment); } } Substitution sub = Substituter.SubstitutionFromHashtable(varToExpr); foreach (var assignment in remainingAssignments) { assignment.Expr = Substituter.Apply(sub, assignment.Expr); } assignments = remainingAssignments; assumes = SubstitutionHelper.Apply(sub, assumes).ToList(); } while (changed); }
public void RenderSubstitution() { // Arrange // Act var result = SubstitutionHelper.RenderSubstitution(m_htmlHelper, "name").ToHtmlString(); // Assert Assert.Equal("result", result); }
private static QKeyValue CloneAttributes(QKeyValue kv, Dictionary <Variable, Variable> substMap) { if (kv == null) { return(null); } return(new QKeyValue(kv.tok, kv.Key, kv.Params.Select(p => p is Expr ? SubstitutionHelper.Apply(substMap, (Expr)p) : p).ToList(), CloneAttributes(kv.Next, substMap))); }
private void AddBoundVariablesForRemainingVars() { var remainingVars = NotEliminatedVars.Except(IntermediateFrameWithWitnesses); existsVarMap = remainingVars.ToDictionary(v => v, v => (Variable)VarHelper.BoundVariable(v.Name, v.TypedIdent.Type)); var substMap = remainingVars.ToDictionary(v => copyToOriginalVar[v], v => existsVarMap[v]); existsVarMap.Iter(kv => kv.Value.Attributes = CloneAttributes(copyToOriginalVar[kv.Key].Attributes, substMap)); pathExprs = SubstitutionHelper.Apply(existsVarMap, pathExprs).ToList(); }
public void RenderSubstitution_Token() { // Arrange m_mockContext.Setup(c => c.Handler).Returns(new HttpResponseSubstitutionHandler(null)); // Act var result = SubstitutionHelper.RenderSubstitution(m_htmlHelper, "name").ToHtmlString(); // Assert Assert.Equal(HttpResponseSubstitutionHandler.Token("name"), result); }
public void BasicSubstitution() { var configuration = new ConfigurationBuilder() .AddInMemoryCollection( new Dictionary <string, string> { ["SubstituteKey"] = "SubstituteValue" } ) .Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders("${SubstituteKey}", configuration); Assert.Equal("SubstituteValue", value); }
public void MultipleSubstitution() { var configuration = new ConfigurationBuilder() .AddInMemoryCollection( new Dictionary <string, string> { ["Database:Username"] = "******", ["Database:Password"] = "******" } ) .Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders( "Server=.;Database=Local.Database;User ID=${Database:Username};Password=${Database:Password}", configuration ); Assert.Equal("Server=.;Database=Local.Database;User ID=user;Password=Password1!", value); }
public Grammar GrammarFromText(string content) { var result = new Grammar(); var helper = new SubstitutionHelper(); content = content.Replace("\r\n", "\n"); var lines = content.Split('\n'); var lineCount = 0; foreach (var line in lines) { lineCount++; if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#")) { continue; } if (!line.Contains(":")) { throw new TinyGrammarException(string.Format("Error on line {0}: missing \":\".", lineCount)); } var symbolEndPosition = line.IndexOf(":"); var symbolName = line.Substring(0, symbolEndPosition); var sentenceExpression = line.Substring(symbolEndPosition + 1, line.Length - 1 - symbolEndPosition); sentenceExpression = helper.HandleSpecialCharacters(sentenceExpression); foreach (var altSentenceExpression in helper.GetAlternativeExpressions(sentenceExpression)) { result.AddSubstitution( helper.CleanupSymbolName(symbolName), helper.UnHandleSpecialCharacters(altSentenceExpression) ); } } return(result); }
public void PrefixSubstitution() { var configuration = new ConfigurationBuilder() .WithPrefix( "prefixed", prefixed => { prefixed.AddInMemoryCollection( new Dictionary <string, string> { ["Key"] = "PrefixedValue" } ); } ) .Build(); var value = SubstitutionHelper.ReplaceSubstitutionPlaceholders("${prefixed:Key}", configuration); Assert.Equal("PrefixedValue", value); }
private void ComputeWitnessedTransitionRelationExprs() { witnessedTransitionRelations = new List <Expr>(); Dictionary <Variable, List <CommutativityWitness> > varToWitnesses = trc.FrameWithWitnesses. Where(x => NotEliminatedVars.Contains(frameIntermediateCopy[x])). ToDictionary( x => frameIntermediateCopy[x], x => trc.globalVarToWitnesses[(GlobalVariable)x]); foreach (var witnessSet in varToWitnesses.Values.CartesianProduct()) { Dictionary <Variable, Expr> witnessSubst = new Dictionary <Variable, Expr>(); foreach (Tuple <Variable, CommutativityWitness> pair in Enumerable.Zip(varToWitnesses.Keys, witnessSet, Tuple.Create)) { CommutativityWitness witness = pair.Item2; witnessSubst[pair.Item1] = ExprHelper.FunctionCall( witness.function, witness.args.ToArray() ); } witnessedTransitionRelations.Add( SubstitutionHelper.Apply(witnessSubst, TransitionRelationExpr)); } }
public Sentence(string expression) { _helper = new SubstitutionHelper(); Expression = _helper.HandleSpecialCharacters(expression); }
public static Sentence FromSymbol(Symbol symbol) { return(new Sentence(SubstitutionHelper.GetExpressionFromSymbolName(symbol.Name))); }
private void IntroduceIntermediateVars() { var oldSub = SubstitutionHelper.FromVariableMap(LatestCopies(trc.PreStateVars)); assignments = new List <Assignment>(); assumes = new List <Expr>(); for (int k = 0; k < trc.path.Count; k++) { if (trc.IsJoint && k == trc.transferIndex) { PopulateIntermediateFrameCopy(); oldSub = SubstitutionHelper.FromVariableMap(LatestCopies(trc.PreStateVars)); } Cmd cmd = trc.path[k]; if (cmd is AssignCmd assignCmd) { assignCmd = assignCmd.AsSimpleAssignCmd; var preState = LatestCopies(); foreach (var v in assignCmd.Lhss) { MakeNewCopy(v.DeepAssignedVariable); } var postState = LatestCopies(); if (QKeyValue.FindBoolAttribute(assignCmd.Attributes, CivlAttributes.BACKWARD)) { var tmp = preState; preState = postState; postState = tmp; } var rhsSub = SubstitutionHelper.FromVariableMap(preState); for (int i = 0; i < assignCmd.Lhss.Count; i++) { var var = postState[assignCmd.Lhss[i].DeepAssignedVariable]; var expr = Substituter.ApplyReplacingOldExprs(rhsSub, oldSub, assignCmd.Rhss[i]); assignments.Add(new Assignment(var, expr)); } } else if (cmd is AssumeCmd assumeCmd) { var sub = SubstitutionHelper.FromVariableMap(LatestCopies()); assumes.Add(Substituter.ApplyReplacingOldExprs(sub, oldSub, assumeCmd.Expr)); } else if (cmd is HavocCmd havocCmd) { foreach (var v in havocCmd.Vars) { MakeNewCopy(v.Decl); } } else { Debug.Assert(false); } } // In case there were no commands from the second action if (trc.IsJoint && trc.path.Count == trc.transferIndex) { PopulateIntermediateFrameCopy(); } }