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); } } }