Пример #1
0
        void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null)
        {
            var ilFile       = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il";
            var csFile       = Path.Combine(TestCasePath, testName + ".cs");
            var expectedFile = Path.Combine(TestCasePath, testName + ".Expected.cs");

            if (!File.Exists(ilFile))
            {
                // re-create .il file if necessary
                CompilerResults output = null;
                try
                {
                    output = Tester.CompileCSharp(csFile, cscOptions);
                    Tester.Disassemble(output.PathToAssembly, ilFile, asmOptions);
                }
                finally
                {
                    if (output != null)
                    {
                        output.TempFiles.Delete();
                    }
                }
            }

            var executable = Tester.AssembleIL(ilFile, asmOptions);
            var decompiled = Tester.DecompileCSharp(executable, decompilerSettings);

            CodeAssert.FilesAreEqual(expectedFile, decompiled, Tester.GetPreprocessorSymbols(cscOptions).ToArray());
        }
Пример #2
0
        void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None)
        {
            var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il";
            var csFile = Path.Combine(TestCasePath, testName + ".cs");

            if (!File.Exists(ilFile))
            {
                // re-create .il file if necessary
                CompilerResults output = null;
                try {
                    output = Tester.CompileCSharp(csFile, cscOptions | CompilerOptions.Library);
                    Tester.Disassemble(output.PathToAssembly, ilFile, asmOptions);
                } finally {
                    if (output != null)
                    {
                        output.TempFiles.Delete();
                    }
                }
            }

            var executable = Tester.AssembleIL(ilFile, asmOptions | AssemblerOptions.Library);
            var decompiled = Tester.DecompileCSharp(executable);

            CodeAssert.FilesAreEqual(csFile, decompiled, cscOptions.HasFlag(CompilerOptions.UseRoslyn) ? null : new[] { "LEGACY_CSC" });
        }
Пример #3
0
        async Task RunIL(string testFileName, CompilerOptions options = CompilerOptions.UseDebug, AssemblerOptions asmOptions = AssemblerOptions.None)
        {
            string          outputFile           = null;
            CompilerResults decompiledOutputFile = null;

            try
            {
                options   |= CompilerOptions.UseTestRunner;
                outputFile = await Tester.AssembleIL(Path.Combine(TestCasePath, testFileName), asmOptions).ConfigureAwait(false);

                string decompiledCodeFile = await Tester.DecompileCSharp(outputFile, Tester.GetSettings(options)).ConfigureAwait(false);

                decompiledOutputFile = await Tester.CompileCSharp(decompiledCodeFile, options).ConfigureAwait(false);

                await Tester.RunAndCompareOutput(testFileName, outputFile, decompiledOutputFile.PathToAssembly, decompiledCodeFile, (options & CompilerOptions.UseTestRunner) != 0, (options & CompilerOptions.Force32Bit) != 0).ConfigureAwait(false);

                Tester.RepeatOnIOError(() => File.Delete(decompiledCodeFile));
                Tester.RepeatOnIOError(() => File.Delete(decompiledOutputFile.PathToAssembly));
            }
            finally
            {
                if (decompiledOutputFile != null)
                {
                    decompiledOutputFile.DeleteTempFiles();
                }
            }
        }
Пример #4
0
        void Run([CallerMemberName] string testName = null, DecompilerSettings settings = null)
        {
            var ilFile = Path.Combine(TestCasePath, testName + ".il");
            var csFile = Path.Combine(TestCasePath, testName + ".cs");

            var executable = Tester.AssembleIL(ilFile, AssemblerOptions.Library);
            var decompiled = Tester.DecompileCSharp(executable, settings);

            CodeAssert.FilesAreEqual(csFile, decompiled);
        }
Пример #5
0
        void Run([CallerMemberName] string testName = null)
        {
            var ilExpectedFile = Path.Combine(TestCasePath, testName + ".il");
            var ilResultFile   = Path.Combine(TestCasePath, testName + ".result.il");

            var executable   = Tester.AssembleIL(ilExpectedFile, AssemblerOptions.Library);
            var disassembled = Tester.Disassemble(executable, ilResultFile, AssemblerOptions.UseOwnDisassembler);

            CodeAssert.FilesAreEqual(ilExpectedFile, ilResultFile);
        }
Пример #6
0
        void Run([CallerMemberName] string testName = null, DecompilerSettings settings = null,
                 AssemblerOptions assemblerOptions  = AssemblerOptions.Library)
        {
            if (settings == null)
            {
                // never use file-scoped namespaces, unless explicitly specified
                settings = new DecompilerSettings {
                    FileScopedNamespaces = false
                };
            }
            var ilFile = Path.Combine(TestCasePath, testName + ".il");
            var csFile = Path.Combine(TestCasePath, testName + ".cs");

            var executable = Tester.AssembleIL(ilFile, assemblerOptions);
            var decompiled = Tester.DecompileCSharp(executable, settings);

            CodeAssert.FilesAreEqual(csFile, decompiled);
        }
Пример #7
0
        void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None)
        {
            var ilFile = Path.Combine(TestCasePath, testName);

            if ((cscOptions & CompilerOptions.Optimize) != 0)
            {
                ilFile += ".opt";
            }
            if ((cscOptions & CompilerOptions.Force32Bit) != 0)
            {
                ilFile += ".32";
            }
            if ((cscOptions & CompilerOptions.UseDebug) != 0)
            {
                ilFile += ".dbg";
            }
            if ((cscOptions & CompilerOptions.UseRoslyn) != 0)
            {
                ilFile += ".roslyn";
            }
            ilFile += ".il";
            var csFile = Path.Combine(TestCasePath, testName + ".cs");

            if (!File.Exists(ilFile))
            {
                // re-create .il file if necessary
                CompilerResults output = null;
                try {
                    output = Tester.CompileCSharp(csFile, cscOptions | CompilerOptions.Library);
                    Tester.Disassemble(output.PathToAssembly, ilFile, asmOptions);
                } finally {
                    if (output != null)
                    {
                        output.TempFiles.Delete();
                    }
                }
            }

            var executable = Tester.AssembleIL(ilFile, asmOptions | AssemblerOptions.Library);
            var decompiled = Tester.DecompileCSharp(executable);

            CodeAssert.FilesAreEqual(csFile, decompiled);
        }
Пример #8
0
        void RunIL(string testFileName, CSharpCompilerOptions options = CSharpCompilerOptions.UseDebug, AssemblerOptions asmOptions = AssemblerOptions.None)
        {
            string          outputFile           = null;
            CompilerResults decompiledOutputFile = null;

            try {
                outputFile = Tester.AssembleIL(Path.Combine(TestCasePath, testFileName), asmOptions);
                string decompiledCodeFile = Tester.DecompileCSharp(outputFile, Tester.GetSettings(options));
                decompiledOutputFile = Tester.CompileCSharp(decompiledCodeFile, options);

                Tester.RunAndCompareOutput(testFileName, outputFile, decompiledOutputFile.PathToAssembly, decompiledCodeFile);

                File.Delete(decompiledCodeFile);
                File.Delete(decompiledOutputFile.PathToAssembly);
            } finally {
                if (decompiledOutputFile != null)
                {
                    decompiledOutputFile.TempFiles.Delete();
                }
            }
        }