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();
}
}
