public void TestNotEndInReturn()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.LoadInt, 0));
var func = new Function(
new FunctionDefinition("main", new List<VMType>(), intType),
instructions,
new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(func));
try
{
container.Execute();
Assert.Fail("Expected without return to not pass.");
}
catch (VerificationException e)
{
Assert.AreEqual("0: Functions must end with a return instruction.", e.Message);
}
}
}
public void TestIntDefaultValue()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var funcDef = new FunctionDefinition("main", new List<VMType>(), intType);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.LoadLocal, 0));
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(funcDef, instructions, Enumerable.Repeat(intType, 1).ToList());
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(0, container.Execute());
}
}
public void TestBranchNotEqual()
{
using (var container = new Win64Container())
{
container.LoadAssembly(Assembly.SingleFunction(
this.CreateBranchProgram(container, OpCodes.BranchNotEqual, 2, 1)));
Assert.AreEqual(1, container.Execute());
}
using (var container = new Win64Container())
{
container.LoadAssembly(Assembly.SingleFunction(
this.CreateBranchProgram(container, OpCodes.BranchNotEqual, 1, 1)));
Assert.AreEqual(0, container.Execute());
}
}
public void TestCall()
{
for (int i = 1; i <= 16; i++)
{
using (var container = new Win64Container())
{
var mainFunc = TestProgramGenerator.AddMainFunction(container, i);
mainFunc.Optimize = true;
var addFunc = TestProgramGenerator.AddFunction(container, i);
addFunc.Optimize = true;
var assembly = new Assembly(mainFunc, addFunc);
container.VirtualMachine.LoadAssembly(assembly);
Assert.AreEqual(i * (1 + i) / 2, container.Execute());
}
}
}
public void TestDiv()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var funcDef = new FunctionDefinition("main", new List<VMType>(), intType);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.LoadInt, 4));
instructions.Add(new Instruction(OpCodes.LoadInt, 2));
instructions.Add(new Instruction(OpCodes.DivInt));
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(funcDef, instructions, new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(4 / 2, container.Execute());
}
}
public void DefinitionOrder()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var assemblyFunctions = new List<Function>();
Action testFn = () =>
{
var def = new FunctionDefinition("test", new List<VMType>(), intType);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.LoadInt, 1));
instructions.Add(new Instruction(OpCodes.LoadInt, 2));
instructions.Add(new Instruction(OpCodes.AddInt));
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(def, instructions, new List<VMType>());
assemblyFunctions.Add(func);
};
Action mainFn = () =>
{
var def = new FunctionDefinition("main", new List<VMType>(), intType);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.Call, "test", new List<VMType>()));
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(def, instructions, new List<VMType>());
assemblyFunctions.Add(func);
};
mainFn();
testFn();
container.LoadAssembly(new Assembly(assemblyFunctions));
Assert.AreEqual(3, container.Execute());
}
}
public void TestEmpty()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var func = new Function(
new FunctionDefinition("main", new List<VMType>(), intType),
new List<Instruction>(),
new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(func));
try
{
container.Execute();
Assert.Fail("Expected empty functions to not pass.");
}
catch (VerificationException e)
{
Assert.AreEqual("0: Empty functions are not allowed.", e.Message);
}
}
}
public void TestRecursive2()
{
using (var container = new Win64Container())
{
var mainFunc = TestProgramGenerator.MainWithIntCall(container, "fib", 11);
mainFunc.Optimize = true;
var sumFunc = TestProgramGenerator.RecursiveFib(container);
sumFunc.Optimize = true;
var assembly = new Assembly(mainFunc, sumFunc);
container.LoadAssembly(assembly);
Assert.AreEqual(89, container.Execute());
}
}
public void TestSimple3()
{
using (var container = new Win64Container())
{
var func = TestProgramGenerator.Simple3(container);
func.Optimize = true;
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(15, container.Execute());
}
}
public void TestNegativeSum()
{
using (var container = new Win64Container())
{
int count = 10;
var func = TestProgramGenerator.NegativeSumNoneLoop(container, count);
func.Optimize = true;
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(TestProgramGenerator.NegativeSumResult(count), container.Execute());
}
}
public void TestProduct()
{
using (var container = new Win64Container())
{
int count = 10;
int product = Enumerable.Aggregate(Enumerable.Range(1, count), 1, (total, current) => total * current);
var func = TestProgramGenerator.ProductNoneLoop(container, count);
func.Optimize = true;
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(product, container.Execute());
}
}
public void TestMixedArguments()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var floatType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Float);
var parameters = new List<VMType>() { intType, floatType, intType, floatType, intType, floatType };
container.VirtualMachine.Binder.Define(FunctionDefinition.NewExternal<FuncIntArgIntFloatIntFloatIntFloat>(
"add",
parameters,
intType,
MixedAdd));
var def = new FunctionDefinition("main", new List<VMType>(), intType);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.LoadInt, 1));
instructions.Add(new Instruction(OpCodes.LoadFloat, 2.0f));
instructions.Add(new Instruction(OpCodes.LoadInt, 3));
instructions.Add(new Instruction(OpCodes.LoadFloat, 4.0f));
instructions.Add(new Instruction(OpCodes.LoadInt, 5));
instructions.Add(new Instruction(OpCodes.LoadFloat, 6.0f));
instructions.Add(new Instruction(
OpCodes.Call,
"add",
parameters));
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(def, instructions, new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(1 + 2 + 3 + 4 + 5 + 6, container.Execute());
}
}
public void TestCallOrder()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var paramsType = Enumerable.Repeat(intType, 2).ToList();
var addFunc = new Function(
new FunctionDefinition("sub", paramsType, intType),
new List<Instruction>()
{
new Instruction(OpCodes.LoadArgument, 0),
new Instruction(OpCodes.LoadArgument, 1),
new Instruction(OpCodes.SubInt),
new Instruction(OpCodes.Ret)
},
new List<VMType>())
{
Optimize = true
};
var mainFunc = new Function(
new FunctionDefinition("main", new List<VMType>(), intType),
new List<Instruction>()
{
new Instruction(OpCodes.LoadInt, 6),
new Instruction(OpCodes.LoadInt, 2),
new Instruction(OpCodes.Call, "sub", paramsType.ToList()),
new Instruction(OpCodes.Ret)
},
new List<VMType>())
{
Optimize = true
};
container.LoadAssembly(new Assembly(addFunc, mainFunc));
Assert.AreEqual(4, container.Execute());
}
}
public void TestLessThanFloat()
{
using (var container = new Win64Container())
{
container.LoadAssembly(Assembly.SingleFunction(
this.CreateBranchFloatProgram(container, OpCodes.BranchLessThan, 1, 2)));
Assert.AreEqual(1, container.Execute());
}
using (var container = new Win64Container())
{
container.LoadAssembly(Assembly.SingleFunction(
this.CreateBranchFloatProgram(container, OpCodes.BranchLessThan, 1, 1)));
Assert.AreEqual(0, container.Execute());
}
using (var container = new Win64Container())
{
container.LoadAssembly(Assembly.SingleFunction(
this.CreateBranchFloatProgram(container, OpCodes.BranchLessThan, 2, 1)));
Assert.AreEqual(0, container.Execute());
}
}
public void TestRecursive1()
{
using (var container = new Win64Container())
{
var assembly = new Assembly(
TestProgramGenerator.MainWithIntCall(container, "sum", 10),
TestProgramGenerator.ResursiveSum(container));
container.LoadAssembly(assembly);
Assert.AreEqual(55, container.Execute());
}
}
public void TestSumLocal()
{
using (var container = new Win64Container())
{
int count = 100;
var func = TestProgramGenerator.SumNoneLoopLocal(container, count);
func.Optimize = true;
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual((count * (count + 1)) / 2, container.Execute());
}
}
public void TestStackArguments2()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var parameters = Enumerable.Repeat(intType, 8).ToList();
container.VirtualMachine.Binder.Define(FunctionDefinition.NewExternal<FuncIntArgIntIntIntIntIntIntIntInt>(
"add",
parameters,
intType,
StackAdd));
var def = new FunctionDefinition("main", new List<VMType>(), intType);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.LoadInt, 1));
instructions.Add(new Instruction(OpCodes.LoadInt, 2));
instructions.Add(new Instruction(OpCodes.LoadInt, 3));
instructions.Add(new Instruction(OpCodes.LoadInt, 4));
instructions.Add(new Instruction(OpCodes.LoadInt, 5));
instructions.Add(new Instruction(OpCodes.LoadInt, 6));
instructions.Add(new Instruction(OpCodes.LoadInt, 7));
instructions.Add(new Instruction(OpCodes.LoadInt, 8));
instructions.Add(new Instruction(
OpCodes.Call,
"add",
parameters));
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(def, instructions, new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(func));
Assert.AreEqual(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8, container.Execute());
}
}
public void TestRecursive2()
{
using (var container = new Win64Container())
{
var assembly = new Assembly(
TestProgramGenerator.MainWithIntCall(container, "fib", 11),
TestProgramGenerator.RecursiveFib(container));
container.LoadAssembly(assembly);
Assert.AreEqual(89, container.Execute());
}
}
public void TestArguments()
{
for (int i = 16; i <= 16; i++)
{
using (var container = new Win64Container())
{
var assembly = new Assembly(
TestProgramGenerator.AddMainFunction(container, i),
TestProgramGenerator.AddFunction(container, i));
container.VirtualMachine.LoadAssembly(assembly);
Assert.AreEqual(i * (1 + i) / 2, container.Execute());
}
}
}
public void TestCallVoid()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var voidType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Void);
var nopFunc = new Function(
new FunctionDefinition("nop", new List<VMType>(), voidType),
new List<Instruction>()
{
new Instruction(OpCodes.Ret)
},
new List<VMType>())
{
Optimize = true
};
var mainFunc = new Function(
new FunctionDefinition("main", new List<VMType>(), intType),
new List<Instruction>()
{
new Instruction(OpCodes.Call, "nop", new List<VMType>()),
new Instruction(OpCodes.LoadInt, 0),
new Instruction(OpCodes.Ret)
},
new List<VMType>())
{
Optimize = true
};
container.LoadAssembly(new Assembly(nopFunc, mainFunc));
Assert.AreEqual(0, container.Execute());
}
}
public void TestVoidParameter()
{
using (var container = new Win64Container())
{
var voidType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Void);
var instructions = new List<Instruction>();
instructions.Add(new Instruction(OpCodes.Ret));
var func = new Function(
new FunctionDefinition("test", new List<VMType>() { voidType }, voidType),
instructions,
new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(func));
try
{
container.Execute();
Assert.Fail("Expected void parameter to not pass.");
}
catch (VerificationException e)
{
Assert.AreEqual("0: 'Void' is not a valid parameter type.", e.Message);
}
}
}
public void TestNoMain()
{
using (var container = new Win64Container())
{
var intType = container.VirtualMachine.TypeProvider.GetPrimitiveType(PrimitiveTypes.Int);
var testFunc = new Function(
new FunctionDefinition("test", new List<VMType>() { intType }, intType),
new List<Instruction>()
{
new Instruction(OpCodes.LoadInt, 0),
new Instruction(OpCodes.Ret)
},
new List<VMType>());
container.LoadAssembly(Assembly.SingleFunction(testFunc));
try
{
container.Execute();
Assert.Fail("Expected no entry point to not pass.");
}
catch (Exception e)
{
Assert.AreEqual("There is no entry point defined.", e.Message);
}
}
}