public void ScopedEnvironment_AssignDataShape_expectPassThrough_NoReplace()
{
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.AssignDataShape("a");
_mockEnv.Verify(a => a.AssignDataShape("a"));
}
public override IDatum Evaluate(Vector list, ScopedEnvironment env)
{
var value = Evaluator.Eval(list.CAR(), env);
if (value is Bool)
{
return(new Atom("boolean"));
}
else if (value is Number)
{
return(new Atom("number"));
}
else if (value is SExpression)
{
return(new Atom("atom"));
}
else if (value is Atom)
{
return(new Atom("atom"));
}
else if (value is Symbol)
{
return(new Atom("symbol"));
}
else
{
return(new Atom("list"));
}
}
public void ScopedEnvironment_CommitAssign_expectPassThrough()
{
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.CommitAssign();
_mockEnv.Verify(a => a.CommitAssign());
}
public void ScopedEnvironment_ToJson()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
Assert.AreEqual("", scopedEnvironment.ToJson());
}
public void ScopedEnvironment_ApplyUpdateTestNegative()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(1)]]", "[[a]]");
SetupReplacementFunctionDoesNotOccur(scopedEnvironment, a => a.ApplyUpdate("[[b]]", ax => ax, 1));
}
public void ScopedEnvironment_EvalForDataMergeTestNegative()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
SetupReplacementFunctionDoesNotOccur(scopedEnvironment, a => a.EvalForDataMerge("[[b]]", 1));
}
public void ScopedEnvironment_EvalAssignFromNestedNumericTestNegative()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(1)]]", "[[a]]");
SetupReplacementFunctionDoesNotOccur(scopedEnvironment, a => a.EvalAssignFromNestedNumeric("[[b]]", It.IsAny <CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult>(), 1));
}
public void ScopedEnvironment_SortRecordSetTestNegative()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
SetupReplacementFunctionDoesNotOccur(scopedEnvironment, a => a.SortRecordSet("[[b]]", It.IsAny <bool>(), 1));
}
public void ScopedEnvironment_ToStar_expectPassThrough()
{
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.ToStar("[[a]]");
_mockEnv.Verify(a => a.ToStar("[[Person(*)]]"));
}
public void ScopedEnvironment_AllErrors_expectPassThrough()
{
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
var x = scopedEnvironment.AllErrors;
_mockEnv.Verify(a => a.AllErrors);
}
public void ScopedEnvironment_AddError_expectPassThrough()
{
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.AddError("bob");
_mockEnv.Verify(a => a.AddError("bob"));
}
public override IDatum Evaluate(Vector list, ScopedEnvironment env)
{
// (invoke-static type method args)
if (list.Length < 2)
{
throw new ArgumentException("INVOKE-STATIC is missing arguments.");
}
var arr = (IDatum[])list.Value;
var type = (System.Type)Evaluator.Eval(arr[0], env).Value;
var method = (string)Evaluator.Eval(arr[1], env).Value;
var args = arr.Skip(2).Select((datum) =>
{
return(Evaluator.Eval(datum, env).Value);
}).ToArray();
//var m = type.GetMethod(method, new Type[] { arr[2].Value.GetType() });
var result = type.InvokeMember(method,
BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Static,
null, null, args);
return(new Atom(result));
}
public void ScopedEnvironment_HasErrors_expectPassThrough()
{
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.HasErrors();
_mockEnv.Verify(a => a.HasErrors());
}
public void ScopedEnvironment_AddError_expectPassThrough()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.AddError("bob");
_mockEnv.Verify(a => a.AddError("bob", false));
}
public void ScopedEnvironment_EvalJContainer_Should()
{
var datasource = "[[@Person(*).Name]]";
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, datasource, "[[a]]");
scopedEnvironment.EvalJContainer(datasource);
_mockEnv.Verify(environment => environment.EvalJContainer(datasource));
}
public void ScopedEnvironment_AssignDataShape_expectPassThrough()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.AssignDataShape("[[a]]");
_mockEnv.Verify(a => a.AssignDataShape("[[Person(*)]]"));
}
public void ScopedEnvironment_HasRecordSet_expectPassThrough()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.HasRecordSet("a");
_mockEnv.Verify(a => a.HasRecordSet("a"));
}
public void ScopedEnvironment_GetIndexes_ShouldGetIndex()
{
var datasource = "[[@Person(*).Name]]";
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, datasource, "[[a]]");
scopedEnvironment.GetIndexes(datasource);
_mockEnv.Verify(environment => environment.GetIndexes(datasource));
}
public void GivenListOfJsonObjct_ScopedEnvironment_EvalForJson_ShouldAddJsonObject()
{
var personName = "[[@Person().Name]]";
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, personName, "[[a]]");
scopedEnvironment.EvalForJson(personName);
_mockEnv.Verify(environment => environment.EvalForJson(personName, false));
}
public void ScopedEnvironment_FetchErrors_expectPassThrough()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.FetchErrors();
_mockEnv.Verify(a => a.FetchErrors());
}
public void ScopedEnvironment_AssignJson_expectPassThrough()
{
var personName = "[[@Person(*).Name]]";
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, personName, "[[a]]");
scopedEnvironment.AssignJson(new AssignValue(personName, "[[a]]"), 0);
_mockEnv.Verify(environment => environment.AssignJson(new AssignValue(personName, "[[a]]"), 0));
}
public void ScopedEnvironment_Assign_HasUpdateValue_ExpectAssignReplacedOnRight()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(1)]]", "[[a]]");
scopedEnvironment.Assign("[[a]]", "[[a]]", 1);
_mockEnv.Verify(a => a.Assign("[[Person(1)]]", "[[Person(1)]]", 0));
}
public void ScopedEnvironment_Assign_ExpectNoReplacement_IfNoAlias()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.Assign("[[b]]", "bob", 0);
_mockEnv.Verify(a => a.Assign("[[b]]", "bob", 0));
}
public void ScopedEnvironment_AssignStrict()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.AssignStrict("[[a]]", "bob", 0);
_mockEnv.Verify(a => a.AssignStrict("[[Person(*)]]", "bob", 0), Times.Once);
}
public override IDatum Evaluate(Vector list, ScopedEnvironment env)
{
if (list.Length != 1)
{
throw new ArgumentException("SPLICE takes 2 arguments.");
}
return(Evaluator.Eval(list[0], env));
}
public void ScopedEnvironment_Eval_ExpectNoReplacement_IfNoAlias()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.Eval("[[b]]", 0);
_mockEnv.Verify(a => a.Eval("[[b]]", 0, false, false));
}
public void ScopedEnvironment_Assign_Basic_ExpectAssignReplaced()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.Assign("[[a]]", "bob", 0);
_mockEnv.Verify(a => a.Assign("[[Person(*)]]", "bob", false, 0));
}
public void ScopedEnvironment_EvalStrict_Basic_ExpectEvalStrictReplaced()
{
var _mockEnv = new Mock <IExecutionEnvironment>();
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
scopedEnvironment.EvalStrict("[[a]]", 0);
_mockEnv.Verify(a => a.EvalStrict("[[Person(*)]]", 0));
}
public override IDatum Evaluate(Vector list, ScopedEnvironment env)
{
if (list.Length != 1)
{
throw new ArgumentException("QUOTE is missing arguments.");
}
return(list[0]);
//return list[1];
}
public void ScopedEnvironment_EvalStrict_ExpectNoReplacement_IfNoAlias()
{
//------------Setup for test--------------------------
var scopedEnvironment = new ScopedEnvironment(_mockEnv.Object, "[[Person(*)]]", "[[a]]");
//------------Execute Test---------------------------
scopedEnvironment.EvalStrict("[[b]]", 0);
//------------Assert Results-------------------------
_mockEnv.Verify(a => a.EvalStrict("[[b]]", 0));
}
