public void ToStringReturnsValue()
{
const int constant = 5;
var constantTerm = new ConstantTerm(constant);
Assert.AreEqual(constant.ToString(), constantTerm.ToString());
}
public void Unify_str_con()
{
ConstantTerm term = new ConstantTerm("ali");
StructureTerm s = new StructureTerm("s", 2);
Assert.IsFalse(s.Unify(term));
}
public void Unify_con_str()
{
ConstantTerm con = new ConstantTerm("ali");
StructureTerm term = new StructureTerm("samir", 2);
Assert.IsFalse(con.Unify(term));
}
public void Unify_lis_con()
{
ListTerm list = new ListTerm();
ConstantTerm con = new ConstantTerm();
Assert.IsFalse(list.Unify(con));
}
public void Unify_con_lis()
{
ConstantTerm con = new ConstantTerm("ali");
ListTerm term = new ListTerm();
Assert.IsFalse(con.Unify(term));
}
public void Unify_con_ne_con()
{
ConstantTerm con = new ConstantTerm("ali");
ConstantTerm term = new ConstantTerm("samir");
Assert.IsFalse(con.Unify(term));
}
public void Unify_con_eq_con()
{
ConstantTerm con = new ConstantTerm("ali");
ConstantTerm term = new ConstantTerm("ali");
Assert.IsTrue(con.Unify(term));
}
public void IsObject()
{
ConstantTerm t = new ConstantTerm();
AbstractTerm a = new ConstantTerm();
Assert.IsFalse(t.IsObject);
Assert.IsFalse(a.IsObject);
}
public void IsStructure()
{
ConstantTerm t = new ConstantTerm();
AbstractTerm a = new ConstantTerm();
Assert.IsFalse(t.IsStructure);
Assert.IsFalse(a.IsStructure);
}
public void IsConstant()
{
ConstantTerm t = new ConstantTerm();
AbstractTerm a = new ConstantTerm();
Assert.IsTrue(t.IsConstant);
Assert.IsTrue(a.IsConstant);
}
public void IsReference()
{
ConstantTerm t = new ConstantTerm();
AbstractTerm a = new ConstantTerm();
Assert.IsFalse(t.IsReference);
Assert.IsFalse(a.IsReference);
}
public void Unify_after_assignment()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("test");
term.Assign(con);
Assert.AreEqual(term.Unify(con), con.Unify(term));
}
public void Bind()
{
ConstantTerm term = new ConstantTerm();
ConstantTerm term2 = new ConstantTerm();
term.Bind(term2);
Assert.AreSame(term, term.Reference());
}
public void Reference()
{
ConstantTerm term1 = new ConstantTerm();
ConstantTerm term2 = new ConstantTerm();
term1.Bind(term2);
Assert.AreSame(term1, term1.Reference());
}
public void Unify_con_ref()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("ali");
Assert.IsTrue(con.Unify(term));
Assert.AreSame(term.Data(), con.Data());
}
public void SparqlExpressionsXPathReplaceNullInCanParallelise2()
{
// when
var find = new VariableTerm("find");
var replace = new ConstantTerm(new StringNode(null, "replacement"));
ReplaceFunction func = new ReplaceFunction(new VariableTerm("term"), find, replace);
// then
var canParallelise = func.CanParallelise;
}
public void Push_ConstantTerm()
{
AMHeap heap = new AMHeap();
ConstantTerm con = new ConstantTerm("Hello, World!");
heap.Push(con);
Assert.AreSame(con, heap.Top());
}
private bool InvokePredicate(Type type, MethodInfo methodInfo, AMForeignPredicate fp, AbstractMachineState state, Assembly loadedAssembly, ArrayList methodArguments)
{
object[] arguments = methodArguments.ToArray();
object returnedResult = null;
object baseObject = null;
baseObject = Activator.CreateInstance(type);
returnedResult = type.InvokeMember(_methodName,
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
baseObject,
arguments);
int registerIndex = 0;
foreach (AMForeignPredicateArgument fArgument in fp.Arguments)
{
if (fArgument.PassingType == AMForeignPredicateArgument.PASS_OUT ||
fArgument.PassingType == AMForeignPredicateArgument.PASS_INOUT)
{
AbstractTerm term = ((AbstractTerm)state["X" + registerIndex.ToString()]).Dereference();
if (fArgument.Type == AMForeignPredicateArgument.T_TERM)
{
ConstantTerm argumentVariable = new ConstantTerm(arguments[registerIndex]);
term.Assign(argumentVariable);
}
else
{
if (fArgument.Type == AMForeignPredicateArgument.T_STRING)
{
if (term.IsReference)
{
term.Assign(new ConstantTerm(arguments[registerIndex]));
}
}
}
registerIndex++;
}
}
bool returnValue = false;
if (fp.ReturnType == AMForeignPredicate.R_BOOL)
{
if (returnedResult == null)
{
return(true);
}
else
{
returnValue = (bool)returnedResult;
}
}
return(returnValue);
}
public void Unbind()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("ali");
term.Assign(con);
term.Unbind();
Assert.AreNotSame(term.Reference(), con.Reference());
}
public void ConstantTerm_ConstructorTest()
{
// setup test
// run test
IExpressionTerm term = new ConstantTerm(16);
// validate results
Assert.IsNotNull(term);
Assert.IsInstanceOfType(term, typeof(IExpressionTerm));
Assert.IsInstanceOfType(term, typeof(ConstantTerm));
}
public void Pop_one_item()
{
AMHeap heap = new AMHeap();
ConstantTerm con = new ConstantTerm("ali");
heap.Push(con);
heap.Pop();
Assert.IsNull(heap.Top());
}
public void Unify_ref_con()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm();
Assert.IsTrue(term.Unify(con));
Assert.AreEqual(term.Data(), con.Data());
Assert.AreSame(term.Reference(), con.Reference());
Assert.IsTrue(term.IsConstant);
Assert.IsFalse(term.IsReference);
}
public void ConstantTerm_ToStringTest()
{
// setup test
IExpressionTerm term = new ConstantTerm(3);
// run test
string result = term.ToString();
// validate results
Assert.IsFalse(string.IsNullOrEmpty(result));
Assert.AreEqual("3", result);
}
public void Pop_two_items()
{
AMHeap heap = new AMHeap();
ConstantTerm con = new ConstantTerm("ali");
ConstantTerm first = new ConstantTerm("foo");
heap.Push(first);
heap.Push(con);
heap.Pop();
Assert.AreSame(first, heap.Top());
}
/// <summary>
/// Checks the equality of objects.
/// </summary>
/// <param name="obj">Object to be checked.</param>
/// <returns>True if the objects are equal, false otherwise.</returns>
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
ConstantTerm other = obj as ConstantTerm;
if (other == null)
{
return(false);
}
return(NameId == other.NameId);
}
public void Assign()
{
AbstractTerm term = new AbstractTerm();
ConstantTerm con = new ConstantTerm("ali");
term.Assign(con);
Assert.AreSame(term.Dereference(), con);
Assert.AreSame(term.Dereference(), con.Dereference());
Assert.AreEqual(term.Data(), con.Data());
Assert.AreSame(term.Reference(), con.Reference());
Assert.IsFalse(term.IsList);
Assert.IsFalse(term.IsObject);
Assert.IsFalse(term.IsReference);
Assert.IsFalse(term.IsStructure);
Assert.IsTrue(term.IsConstant);
}
public void ConstantTerm_CalculateResultsNullDieRollerTest()
{
// setup test
IExpressionTerm term = new ConstantTerm(8);
// run test
IReadOnlyList <TermResult> results = term.CalculateResults(null);
// validate results
Assert.IsNotNull(results);
Assert.AreEqual(1, results.Count);
TermResult r = results.FirstOrDefault();
Assert.IsNotNull(r);
Assert.AreEqual(1, r.Scalar);
Assert.AreEqual(8, r.Value);
Assert.AreEqual("ConstantTerm", r.Type);
}
/// <summary>
/// Substitutes a primary expression which is a Node term for a virtual Node term.
/// </summary>
/// <param name="expr">Expression.</param>
/// <returns></returns>
protected ISparqlExpression SubstitutePrimaryExpression(ISparqlExpression expr)
{
if (expr.GetType().Equals(_exprType))
{
ConstantTerm term = (ConstantTerm)expr;
INode curr = term.Evaluate(null, 0);
TNodeID id = _provider.GetID(curr);
if (id == null || id.Equals(_provider.NullID))
{
throw new RdfQueryException("Cannot transform the Expression to use Virtual Nodes");
}
INode virt = CreateVirtualNode(id, curr);
return(new ConstantTerm(virt));
}
else
{
return(expr);
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = (state["X0"] as AbstractTerm).Dereference();
ConsoleKeyInfo keyInfo = Console.ReadKey();
int intValue = Convert.ToInt32(keyInfo.KeyChar);
ConstantTerm readChar = new ConstantTerm(intValue.ToString());
if (X0.Unify(readChar))
{
program.Next();
}
else
{
state.Backtrack();
}
}
public override void Execute(AbstractMachineState state)
{
AMProgram program = (AMProgram)state.Program;
AbstractTerm X0 = (state["X0"] as AbstractTerm).Dereference();
ConsoleKeyInfo keyInfo = Console.ReadKey();
int intValue = Convert.ToInt32(keyInfo.KeyChar);
ConstantTerm readChar = new ConstantTerm(intValue.ToString());
if (X0.Unify(readChar))
{
program.Next();
}
else
{
state.Backtrack();
}
}
public void UnifyLocalValue()
{
AbstractMachineState state = SetupMachine();
UnifyLocalValueInstruction i = new UnifyLocalValueInstruction();
ConstantTerm con = new ConstantTerm("ali");
state.S = con;
object[] args = { "X0" };
i.Process(args);
i.Execute(state);
Assert.AreEqual("unify_local_value", i.Name());
Assert.AreEqual(1, i.NumberOfArguments());
AbstractTerm X0 = (AbstractTerm)state["X0"];
Assert.AreEqual("ali", X0.Dereference().Data());
}
private bool InvokePredicate(Type type, MethodInfo methodInfo, AMForeignPredicate fp, AbstractMachineState state, Assembly loadedAssembly, ArrayList methodArguments)
{
object[] arguments = methodArguments.ToArray();
object returnedResult = null;
object baseObject = null;
baseObject = Activator.CreateInstance(type);
returnedResult = type.InvokeMember(_methodName,
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
baseObject,
arguments);
int registerIndex = 0;
foreach (AMForeignPredicateArgument fArgument in fp.Arguments)
{
if (fArgument.PassingType == AMForeignPredicateArgument.PASS_OUT ||
fArgument.PassingType == AMForeignPredicateArgument.PASS_INOUT)
{
AbstractTerm term = ((AbstractTerm)state["X" + registerIndex.ToString()]).Dereference();
if (fArgument.Type == AMForeignPredicateArgument.T_TERM)
{
ConstantTerm argumentVariable = new ConstantTerm(arguments[registerIndex]);
term.Assign(argumentVariable);
}
else
{
if (fArgument.Type == AMForeignPredicateArgument.T_STRING)
{
if (term.IsReference)
{
term.Assign(new ConstantTerm(arguments[registerIndex]));
}
}
}
registerIndex++;
}
}
bool returnValue = false;
if (fp.ReturnType == AMForeignPredicate.R_BOOL)
{
if (returnedResult == null)
{
return true;
}
else
{
returnValue = (bool)returnedResult;
}
}
return returnValue;
}
