public void Test_EitherArg_Optional_WrongType()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalIntOrStringThenAtomArg));
ZilObject[] args = { ctx.FALSE };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_ZilObjectArrayArg_Required_Fail()
{
var methodInfo = GetMethod(nameof(Dummy_RequiredZilObjectArrayArg));
ZilObject[] args = { };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_ContextOnly()
{
var methodInfo = GetMethod(nameof(Dummy_ContextOnly));
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, new ZilObject[] { });
object[] expected = { ctx };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_EitherArg_Optional_Provided()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalIntOrStringThenAtomArg));
ZilObject[] args = { new ZilFix(123), ctx.TRUE };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, 123, ctx.TRUE };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_StructArg_Fail_TooFewArgs()
{
var methodInfo = GetMethod(nameof(Dummy_IntStringStructArg));
ZilObject[] args =
{
new ZilList(new ZilObject[] { new ZilFix(123) })
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_OptionalArg_Provided()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalIntThenStringArg));
ZilObject[] args = { new ZilFix(42), ZilString.FromString("hello") };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, 42, "hello" };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_EitherArg_String()
{
var methodInfo = GetMethod(nameof(Dummy_IntOrStringOrIntStringArg));
ZilObject[] args = { ZilString.FromString("hi") };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, "hi" };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_ZilObjectArg()
{
var methodInfo = GetMethod(nameof(Dummy_ZilObjectArg));
var arg = new ZilList(null, null);
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, new ZilObject[] { arg });
object[] expected = { ctx, arg };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_DeclArg_OptionalMiddle()
{
var methodInfo = GetMethod(nameof(Dummy_MultiOptionalDeclArgs));
ZilObject[] args = { new ZilFix(2) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, 1, 2 };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_OptionalArg_EndOfArgs()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalIntArg));
ZilObject[] args = { };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, 69105 };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_StringArg()
{
var methodInfo = GetMethod(nameof(Dummy_StringArgs));
ZilObject[] args = { ZilString.FromString("hello"), ZilString.FromString("world") };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, "hello", "world" };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_IntArg()
{
var methodInfo = GetMethod(nameof(Dummy_IntArgs));
ZilObject[] args = { new ZilFix(123), new ZilFix(456) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, 123, 456 };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_DeclArg_Pass()
{
var methodInfo = GetMethod(nameof(Dummy_DeclArg));
ZilObject[] args = { ctx.GetStdAtom(StdAtom.ZILF) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, args[0] };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_SequenceArg()
{
var methodInfo = GetMethod(nameof(Dummy_IntStringSequenceArg));
ZilObject[] args = { new ZilFix(1), ZilString.FromString("money") };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, new IntStringSequence {
arg1 = 1,arg2 = "money"
} };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_StringArrayArg()
{
var methodInfo = GetMethod(nameof(Dummy_StringArrayArg));
ZilObject[] args = { ZilString.FromString("hello") };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, new[] { "hello" } };
Assert.AreEqual(2, actual.Length);
Assert.AreEqual(expected[0], actual[0]);
Assert.IsInstanceOfType(actual[1], typeof(string[]));
CollectionAssert.AreEqual((string[])expected[1], (string[])actual[1]);
}
public void Test_IntArrayArg()
{
var methodInfo = GetMethod(nameof(Dummy_IntArrayArg));
ZilObject[] args = { new ZilFix(123), new ZilFix(456) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, new[] { 123, 456 } };
Assert.AreEqual(2, actual.Length);
Assert.AreEqual(expected[0], actual[0]);
Assert.IsInstanceOfType(actual[1], typeof(int[]));
CollectionAssert.AreEqual((int[])expected[1], (int[])actual[1]);
}
public void Test_ZilObjectArrayArg_Empty()
{
var methodInfo = GetMethod(nameof(Dummy_ZilObjectArrayArg));
ZilObject[] args = { };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, args };
Assert.AreEqual(expected.Length, actual.Length);
Assert.AreEqual(expected[0], actual[0]);
Assert.IsInstanceOfType(actual[1], typeof(ZilObject[]));
TestHelpers.AssertStructurallyEqual((ZilObject[])expected[1], (ZilObject[])actual[1]);
}
public void Test_StructArg_Optional_Fail_TooFewArgs()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalStructArrayArg));
ZilObject[] args =
{
new ZilVector(
new ZilFix(100),
new ZilFix(200),
new ZilFix(300))
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_DeclArg_VarArgs_Fail()
{
var methodInfo = GetMethod(nameof(Dummy_DeclVarArgs));
ZilObject[] args =
{
new ZilFix(1),
new ZilFix(2),
ZilAtom.Parse("MONEY",ctx),
ZilAtom.Parse("SHOW", ctx)
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_ApplicableArg()
{
var methodInfo = GetMethod(nameof(Dummy_ApplicableArg));
var plusSubr = ctx.GetSubrDelegate("+");
Debug.Assert(plusSubr != null);
ZilObject[] args = { new ZilFix(1), new ZilSubr("+", plusSubr) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, new ZilFix(1), new ZilSubr("+", plusSubr) };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_StructArg_Array()
{
var methodInfo = GetMethod(nameof(Dummy_IntStringStructArrayArg));
ZilObject[] args =
{
new ZilList(new ZilObject[]
{
new ZilFix(1), ZilString.FromString("money")
}),
new ZilList(new ZilObject[]
{
new ZilFix(2), ZilString.FromString("show")
}),
new ZilList(new ZilObject[]
{
new ZilFix(3), ZilString.FromString("ready")
})
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected =
{
ctx,
new[]
{
new IntStringStruct {
arg1 = 1,arg2 = "money"
},
new IntStringStruct {
arg1 = 2,arg2 = "show"
},
new IntStringStruct {
arg1 = 3,arg2 = "ready"
}
}
};
Assert.AreEqual(2, actual.Length);
Assert.AreEqual(expected[0], actual[0]);
Assert.IsInstanceOfType(actual[1], typeof(IntStringStruct[]));
CollectionAssert.AreEqual((IntStringStruct[])expected[1], (IntStringStruct[])actual[1]);
}
public void Test_DeclArg_VarArgs_Pass()
{
var methodInfo = GetMethod(nameof(Dummy_DeclVarArgs));
ZilObject[] args =
{
new ZilFix(1),
ZilAtom.Parse("MONEY",ctx),
new ZilFix(2),
ZilAtom.Parse("SHOW", ctx)
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
Assert.AreEqual(actual.Length, 2);
Assert.AreEqual(actual[0], ctx);
Assert.IsInstanceOfType(actual[1], typeof(ZilObject[]));
TestHelpers.AssertStructurallyEqual(args, (ZilObject[])actual[1]);
}
public void Test_StructArg()
{
var methodInfo = GetMethod(nameof(Dummy_IntStringStructArg));
ZilObject[] args =
{
new ZilList(new ZilObject[]
{
new ZilFix(123), ZilString.FromString("hi")
})
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, new IntStringStruct {
arg1 = 123,arg2 = "hi"
} };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_ApplicableArrayArg_Custom()
{
var methodInfo = GetMethod(nameof(Dummy_ApplicableArrayArg));
var fooAtom = (ZilAtom)TestHelpers.Evaluate(ctx, "<NEWTYPE FOO LIST>");
TestHelpers.Evaluate(ctx, "<APPLYTYPE FOO FUNCTION>");
ZilObject[] args =
{
new ZilFix(1),
new ZilHash(fooAtom,PrimType.LIST, new ZilList(null, null))
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
Assert.AreEqual(ctx, actual[0]);
Assert.IsInstanceOfType(actual[1], typeof(IApplicable[]));
Assert.AreEqual(2, ((IApplicable[])actual[1]).Length);
}
public void Test_FormArg()
{
var methodInfo = GetMethod(nameof(Dummy_FormArg));
ZilObject[] args =
{
new ZilForm(new ZilObject[]
{
ctx.GetStdAtom(StdAtom.Plus),
new ZilFix(1),
new ZilFix(2)
})
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected = { ctx, args[0] };
CollectionAssert.AreEqual(expected, actual);
}
public void Test_OptionalArg_Fail_WrongType()
{
const string SExpectedMessage = "dummy: arg 1: expected FIX";
var methodInfo = GetMethod(nameof(Dummy_OptionalIntArg));
ZilObject[] args = { ctx.FALSE };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
try
{
decoder.Decode("dummy", ctx, args);
}
catch (ArgumentTypeError ex)
{
StringAssert.EndsWith(ex.Message, SExpectedMessage);
return;
}
Assert.Fail($"Expected {nameof(ArgumentTypeError)}");
}
public void Test_EitherArg_IndirectlyNested_Fail_TooFewArgs()
{
const string SExpectedMessage = "dummy: arg 1 requires exactly 1 element";
var methodInfo = GetMethod(nameof(Dummy_EitherIntOrWrappedStringOrAtomArg));
ZilObject[] args = { new ZilList(null, null) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
try
{
decoder.Decode("dummy", ctx, args);
}
catch (ArgumentCountError ex)
{
StringAssert.EndsWith(ex.Message, SExpectedMessage);
return;
}
Assert.Fail($"Expected {nameof(ArgumentCountError)}");
}
public void Test_EitherArg_IndirectlyNested_Fail_WrongArgType()
{
const string SExpectedMessage = "dummy: arg 1: element 1: expected ATOM or STRING";
var methodInfo = GetMethod(nameof(Dummy_EitherIntOrWrappedStringOrAtomArg));
ZilObject[] args = { new ZilList(new[] { ctx.FALSE }) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
try
{
decoder.Decode("dummy", ctx, args);
}
catch (ArgumentTypeError ex)
{
StringAssert.EndsWith(ex.Message, SExpectedMessage);
return;
}
Assert.Fail($"Expected {nameof(ArgumentTypeError)}");
}
public void Test_DeclArg_Fail()
{
const string SExpectedMessage = "dummy: arg 1: expected ATOM and 'ZILF";
var methodInfo = GetMethod(nameof(Dummy_DeclArg));
ZilObject[] args = { ctx.GetStdAtom(StdAtom.ZILCH) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
try
{
decoder.Decode("dummy", ctx, args);
}
catch (ArgumentTypeError ex)
{
StringAssert.EndsWith(ex.Message, SExpectedMessage);
return;
}
Assert.Fail($"Expected {typeof(ArgumentTypeError)}");
}
public void FromMethodInfo_Requires_ZilObject_Return()
{
var methodInfo = GetMethod(nameof(Dummy_WrongReturn));
ArgDecoder.FromMethodInfo(methodInfo, ctx);
}