public void Test_StructArg_Nested()
{
var methodInfo = GetMethod(nameof(Dummy_OuterStructArg));
ZilObject[] args =
{
new ZilVector(
new ZilFix(123),
new ZilList(new ZilObject[]
{
new ZilFix(456),
ZilString.FromString("foo")
})
)
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected =
{
ctx,
new OuterStruct
{
arg1 = 123,
arg2 = new IntStringStruct
{
arg1 = 456,
arg2 = "foo"
}
}
};
CollectionAssert.AreEqual(expected, actual);
}
public void Test_StructArg_Nested_Fail_WrongStructureType()
{
const string SExpectedMessage = "dummy: arg 1: element 2: expected LIST";
var methodInfo = GetMethod(nameof(Dummy_OuterStructArg));
ZilObject[] args =
{
new ZilVector(
new ZilFix(123),
new ZilVector(
new ZilFix(456),
ZilString.FromString("foo")
)
)
};
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 Test_SequenceArrayArg()
{
var methodInfo = GetMethod(nameof(Dummy_IntStringSequenceArrayArg));
ZilObject[] args =
{
new ZilFix(1), ZilString.FromString("money"),
new ZilFix(2), ZilString.FromString("show")
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected =
{
ctx,
new[]
{
new IntStringSequence {
arg1 = 1,arg2 = "money"
},
new IntStringSequence {
arg1 = 2,arg2 = "show"
}
}
};
Assert.AreEqual(2, actual.Length);
Assert.AreEqual(expected[0], actual[0]);
Assert.IsInstanceOfType(actual[1], typeof(IntStringSequence[]));
CollectionAssert.AreEqual((IntStringSequence[])expected[1], (IntStringSequence[])actual[1]);
}
public void Test_StructArg_Fail_WrongElementType()
{
const string SExpectedMessage = "dummy: arg 1: element 2: expected STRING";
var methodInfo = GetMethod(nameof(Dummy_IntStringStructArg));
ZilObject[] args =
{
new ZilList(new[] { new ZilFix(123), 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_OptionalArg_Fail_OmittedAndExtraArgs()
{
const string SExpectedMessage = "dummy: too many args, starting at arg 2";
const string SExpectedSubMessage = "check types of earlier args, e.g. arg 1";
var methodInfo = GetMethod(nameof(Dummy_OptionalIntThenStringArg));
ZilObject[] args = { ZilString.FromString("foo"), new ZilFix(123) };
try
{
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
catch (ArgumentCountError ex)
{
StringAssert.EndsWith(ex.Message, SExpectedMessage);
Assert.AreEqual(1, ex.Diagnostic.SubDiagnostics.Count);
var sd = ex.Diagnostic.SubDiagnostics[0];
Assert.AreEqual(SExpectedSubMessage, sd.GetFormattedMessage());
return;
}
Assert.Fail($"Expected {typeof(ArgumentCountError)}");
}
public void Test_StructArg_Optional()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalStructArrayArg));
ZilObject[] args =
{
new ZilVector(
ZilString.FromString("o'clock"),
new ZilFix(4),
ZilString.FromString("o'clock"))
};
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
var actual = decoder.Decode("dummy", ctx, args);
object[] expected =
{
ctx,
new OptionalStruct
{
arg1 = 1,
arg2 = 2,
arg3 = 3,
arg4 = "o'clock",
arg5 = 4,
arg6 = "o'clock",
arg7 = "rock"
}
};
CollectionAssert.AreEqual(expected, actual);
}
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_TooManyArgs()
{
var methodInfo = GetMethod(nameof(Dummy_IntArgs));
ZilObject[] args = { new ZilFix(123), new ZilFix(456), new ZilFix(789) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_OptionalArg_TooManyArgs()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalIntArg));
ZilObject[] args = { new ZilFix(1), new ZilFix(2) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_OptionalArg_Fail_TooFewArgs()
{
var methodInfo = GetMethod(nameof(Dummy_OptionalIntThenStringArg));
ZilObject[] args = { new ZilFix(42) };
var decoder = ArgDecoder.FromMethodInfo(methodInfo, ctx);
decoder.Decode("dummy", ctx, args);
}
public void Test_AtomArrayArg_Fail()
{
var methodInfo = GetMethod(nameof(Dummy_AtomArrayArg));
ZilObject[] args = { new ZilFix(123) };
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_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_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_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_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_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_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_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_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_MdlZilRedirect()
{
ctx.CurrentFile.Flags |= FileFlags.MdlZil;
var methodInfo = GetMethod(nameof(Dummy_MdlZilRedirect_From));
ZilObject[] args = { new ZilFix(123) };
var del = ArgDecoder.WrapMethod(methodInfo, ctx);
var actual = del("dummy", ctx, args);
var expected = new ZilFix(246);
TestHelpers.AssertStructurallyEqual(expected, (ZilObject)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_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_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_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_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);
}
