public void CanSubstituteCustom()
{
Substitutor.Register(string.Empty, "user", (key) => Environment.UserName);
string val = Substitutor.Substitute("${user}");
Assert.AreEqual(val, Environment.UserName);
}
public void Const()
{
ctx.Replay();
var subst = new Substitutor(ctx);
var c = m.Int32(4);
var c2 = c.Accept(subst);
Assert.AreSame(c, c2);
}
public void Test2()
{
var s = @"SAY The $animal woke $count times";
Substitutor.ReplaceVars(ref s, globals);
Console.WriteLine("Running SubstitutionTests.Test2 :: " + s);
Assert.Equal("SAY The dog woke 4 times", s);
}
public void Const()
{
var subst = new Substitutor(ctx.Object);
var c = m.Int32(4);
var c2 = c.Accept(subst);
Assert.AreSame(c, c2);
}
public void Test1()
{
var s = @"SAY The $animal woke and $prep (ate|ate)";
Substitutor.ReplaceGroups(ref s);
Substitutor.ReplaceVars(ref s, globals);
Console.WriteLine("Running SubstitutionTests.Test1 :: " + s);
Assert.Equal("SAY The dog woke and then ate", s);
}
/// <summary>
/// Substitutions
/// </summary>
public void DoSubstitutions()
{
Logger.Info("====================================================");
Logger.Info("SUBSTITUTIONS ");
Logger.Info("Evaluating ${today} to : " + Substitutor.Substitute("${today}"));
Logger.Info("Evaluating ${t-1} to : " + Substitutor.Substitute("${t-1}"));
Logger.Info("Evaluating ${t+1} to : " + Substitutor.Substitute("${t+1}"));
Logger.Info("Evaluating ${username} to : " + Substitutor.Substitute("${username}"));
Logger.Info(Environment.NewLine);
}
public void Identifier_GetValue()
{
var id = m.Register(3);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(id))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var cInvalid = id.Accept(subst);
Assert.AreSame(Constant.Invalid, cInvalid);
}
//[Fact]
public void Test4() // FAILS
{
var s = @"SAY The $animal woke $count times";
new ScriptingEngine(globals).Exec("count++;");
Console.WriteLine("globals=" + globals);
Substitutor.ReplaceVars(ref s, globals);
Console.WriteLine("Running SubstitutionTests.Test3 :: " + s);
Assert.Equal("SAY The dog woke 4 times", s);
}
public void Identifier_GetValue()
{
var id = m.Register(3);
ctx.Setup(c => c.GetValue(id)).Returns(Constant.Invalid);
var subst = new Substitutor(ctx.Object);
var cInvalid = id.Accept(subst);
Assert.AreSame(Constant.Invalid, cInvalid);
}
public void CanSubstitute()
{
List <string> vals = new List <string>()
{
"${today}", "${yesterday}"
};
Substitutor.Substitute(vals);
Assert.AreEqual(vals[0], DateTime.Today.ToShortDateString());
Assert.AreEqual(vals[1], DateTime.Today.AddDays(-1).ToShortDateString());
}
public void Identifier_GetValue()
{
var id = m.Register("r3");
var invalid = InvalidConstant.Create(id.DataType);
ctx.Setup(c => c.GetValue(id)).Returns(invalid);
var subst = new Substitutor(ctx.Object);
var cInvalid = id.Accept(subst);
Assert.AreSame(invalid, cInvalid);
}
public void ConditionOf_Invalid()
{
var id = m.Register("r3");
var e = m.Cond(id);
ctx.Setup(c => c.GetValue(id)).Returns(InvalidConstant.Create(id.DataType));
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.IsTrue(e2 is InvalidConstant);
}
public ExpressionPropagator(
IProcessorArchitecture arch,
ExpressionSimplifier simplifier,
SymbolicEvaluationContext ctx,
ProgramDataFlow flow)
{
this.arch = arch;
this.eval = simplifier;
this.ctx = ctx;
this.flow = flow;
this.sub = new Substitutor(ctx);
}
public void Mem_Valid()
{
var id = m.Register(3);
var e = m.Mem16(id);
ctx.Setup(c => c.GetValue(id)).Returns(id);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreEqual("Mem0[r3:word16]", e2.ToString());
}
public ExpressionPropagator(
IPlatform platform,
ExpressionSimplifier simplifier,
SymbolicEvaluationContext ctx,
ProgramDataFlow flow)
{
this.platform = platform;
this.eval = simplifier;
this.ctx = ctx;
this.flow = flow;
this.sub = new Substitutor(ctx);
}
public void Unary_Valid()
{
var id = m.Register(3);
var e = m.Not(id);
ctx.Setup(c => c.GetValue(id)).Returns(id);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreEqual("!r3", e2.ToString());
}
public void Bin_BothValid()
{
var id = m.Register(3);
var e = m.IAdd(id, id);
ctx.Setup(c => c.GetValue(id)).Returns(id);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreEqual("r3 + r3", e2.ToString());
}
public void Bin_LeftInvalid()
{
var id = m.Register(3);
var e = m.IAdd(id, m.Word32(12));
ctx.Setup(c => c.GetValue(id)).Returns(Constant.Invalid);
var subst = new Substitutor(ctx.Object);
var cInvalid = e.Accept(subst);
Assert.AreSame(Constant.Invalid, cInvalid);
}
public void Identifier_GetValue()
{
var id = m.Register(3);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(id))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var cInvalid = id.Accept(subst);
Assert.AreSame(Constant.Invalid, cInvalid);
}
public void Bin_LeftInvalid()
{
var id = m.Register(3);
var e = m.IAdd(id, m.Word32(12));
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(id))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var cInvalid = e.Accept(subst);
Assert.AreSame(Constant.Invalid, cInvalid);
}
public void Bin_BothValid()
{
var id = m.Register(3);
var e = m.IAdd(id, id);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(id))).Return(id);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("r3 + r3", e2.ToString());
}
public void ConditionOf_Valid()
{
var id = m.Register(3);
var e = m.Cond(id);
ctx.Setup(c => c.GetValue(id)).Returns(id);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreEqual("cond(r3)", e2.ToString());
}
public void ConditionOf_Invalid()
{
var id = m.Register(3);
var e = m.Cond(id);
ctx.Setup(c => c.GetValue(id)).Returns(Constant.Invalid);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreSame(Constant.Invalid, e2);
}
public void Bin_BothValid()
{
var id = m.Register(3);
var e = m.IAdd(id, id);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(id))).Return(id);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("r3 + r3", e2.ToString());
}
public void Bin_LeftInvalid()
{
var id = m.Register(3);
var e = m.IAdd(id, m.Word32(12));
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(id))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var cInvalid = e.Accept(subst);
Assert.AreSame(Constant.Invalid, cInvalid);
}
public void ConditionOf_Invalid()
{
var id = m.Register(3);
var e = m.Cond(id);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(id))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreSame(Constant.Invalid, e2);
}
public void Mem_Valid()
{
var id = m.Register(3);
var e = m.Mem16(id);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(id))).Return(id);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("Mem0[r3:word16]", e2.ToString());
}
public void ConditionOf_Valid()
{
var id = m.Register(3);
var e = m.Cond(id);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(id))).Return(id);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("cond(r3)", e2.ToString());
}
public void Unary_Invalid()
{
var id = m.Register("r3");
var e = m.Not(id);
var invalid = InvalidConstant.Create(id.DataType);
ctx.Setup(c => c.GetValue(id)).Returns(invalid);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreSame(invalid, e2);
}
/// <summary>
/// Set the argument value from command line on the property of the object
/// recieving the value.
/// </summary>
/// <param name="argReciever"></param>
/// <param name="val"></param>
/// <param name="rawArgValue"></param>
private static void SetValue(object argReciever, KeyValuePair <ArgAttribute, PropertyInfo> val, string rawArgValue)
{
ArgAttribute argAttr = val.Key;
// First interpret.
string argValue = rawArgValue;
if (argAttr.Interpret)
{
argValue = Substitutor.Substitute(argValue);
}
ReflectionUtils.SetProperty(argReciever, val.Value, argValue);
}
public void SegMem_Valid()
{
var es = m.Frame.CreateTemporary("es", PrimitiveType.Word16);
var bx = m.Frame.CreateTemporary("bx", PrimitiveType.Word16);
var e = m.SegMem16(es, bx);
ctx.Setup(c => c.GetValue(es)).Returns(es);
ctx.Setup(c => c.GetValue(bx)).Returns(bx);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreEqual("Mem0[es:bx:word16]", e2.ToString());
}
public void SegMem_Invalid()
{
var es = m.Frame.CreateTemporary("es", PrimitiveType.Word16);
var bx = m.Frame.CreateTemporary("bx", PrimitiveType.Word16);
var e = m.SegMem16(es, bx);
ctx.Setup(c => c.GetValue(es)).Returns(es);
ctx.Setup(c => c.GetValue(bx)).Returns(Constant.Invalid);
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.AreSame(Constant.Invalid, e2);
}
public void SegMem_Invalid()
{
var es = m.Frame.CreateTemporary("es", PrimitiveType.Word16);
var bx = m.Frame.CreateTemporary("bx", PrimitiveType.Word16);
var e = m.SegMem16(es, bx);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(es))).Return(es);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(bx))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreSame(Constant.Invalid, e2);
}
public void SegMem_Valid()
{
var es = m.Frame.CreateTemporary("es", PrimitiveType.Word16);
var bx = m.Frame.CreateTemporary("bx", PrimitiveType.Word16);
var e = m.SegMem16(es, bx);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(es))).Return(es);
ctx.Expect(c => c.GetValue(Arg <Identifier> .Is.Same(bx))).Return(bx);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("Mem0[es:bx:word16]", e2.ToString());
}
public void SegMem_Invalid()
{
var es = m.Frame.CreateTemporary("es", PrimitiveType.Word16);
var bx = m.Frame.CreateTemporary("bx", PrimitiveType.Word16);
var e = m.SegMemW(es, bx);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(es))).Return(es);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(bx))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreSame(Constant.Invalid, e2);
}
public void ConditionOf_Invalid()
{
var id = m.Register(3);
var e = m.Cond(id);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(id))).Return(Constant.Invalid);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreSame(Constant.Invalid, e2);
}
public void ConditionOf_Valid()
{
var id = m.Register(3);
var e = m.Cond(id);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(id))).Return(id);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("cond(r3)", e2.ToString());
}
public void Mem_Valid()
{
var id = m.Register(3);
var e = m.LoadW(id);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(id))).Return(id);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("Mem0[r3:word16]", e2.ToString());
}
public void SegMem_Valid()
{
var es = m.Frame.CreateTemporary("es", PrimitiveType.Word16);
var bx = m.Frame.CreateTemporary("bx", PrimitiveType.Word16);
var e = m.SegMemW(es, bx);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(es))).Return(es);
ctx.Expect(c => c.GetValue(Arg<Identifier>.Is.Same(bx))).Return(bx);
ctx.Replay();
var subst = new Substitutor(ctx);
var e2 = e.Accept(subst);
Assert.AreEqual("Mem0[es:bx:word16]", e2.ToString());
}
