public void AllSimpleTests()
        {
            var defaultProvider = MakeDefaultProvider();
            var simpleTests = Directory.GetFiles(
                Path.GetFullPath(Path.Combine(ComparisonTest.TestSourceFolder, "SimpleTestCases")),
                "*.cs"
            );
            var failureList = new List<string>();

            foreach (var filename in simpleTests) {
                Console.Write("// {0} ... ", Path.GetFileName(filename));

                try {
                    // We reuse the same type info provider for all the tests in this folder so they run faster
                    using (var test = new ComparisonTest(filename, null, defaultProvider))
                        test.Run();
                } catch (Exception ex) {
                    failureList.Add(Path.GetFileNameWithoutExtension(filename));
                    if (ex.Message == "JS test failed")
                        Debug.WriteLine(ex.InnerException);
                    else
                        Debug.WriteLine(ex);
                }
            }

            Assert.AreEqual(0, failureList.Count,
                String.Format("{0} test(s) failed:\r\n{1}", failureList.Count, String.Join("\r\n", failureList.ToArray()))
            );
        }

 public void Chars()
 {
     using (var test = new ComparisonTest(@"TestCases\Chars.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\CharSwitch.cs"))
         test.Run();
 }

 public void Casts()
 {
     using (var test = new ComparisonTest(@"TestCases\CastToBoolean.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\CastingFromNull.cs"))
         test.Run();
 }

 public void CastingFromNull()
 {
     using (var test = new ComparisonTest(@"TestCases\CastingFromNull.cs"))
     {
         test.Run();
     }
 }

 public void Arithmetic()
 {
     using (var test = new ComparisonTest(@"TestCases\IntegerArithmetic.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\TernaryArithmetic.cs"))
         test.Run();
 }

 public void BinaryTrees()
 {
     using (var test = new ComparisonTest(@"TestCases\BinaryTrees.cs")) {
         test.Run();
         test.Run("8");
     }
 }

 public void Enums()
 {
     using (var test = new ComparisonTest(@"TestCases\Enums.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\EnumArrayLookup.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\EnumSwitch.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\OverloadWithEnum.cs"))
         test.Run();
 }

        public void AllFailingTests()
        {
            var testPath = Path.GetFullPath(Path.Combine(ComparisonTest.TestSourceFolder, "FailingTestCases"));
            var simpleTests = Directory.GetFiles(testPath, "*.cs").Concat(Directory.GetFiles(testPath, "*.vb")).ToArray();

            int passCount = 0;

            foreach (var filename in simpleTests) {
                Console.Write("// {0} ... ", Path.GetFileName(filename));

                try {
                    using (var test = new ComparisonTest(filename))
                        test.Run();

                    passCount += 1;
                } catch (Exception ex) {
                    Console.WriteLine("{0}: {1}", ex.GetType().Name, ex.Message);
                }
            }

            Assert.AreEqual(0, passCount, "One or more tests passed that should have failed");
        }

        public void EscapesOutputFilenames()
        {
            using (var test = new ComparisonTest(
                EvaluatorPool,
                new[] { @"TestCases\HelloWorld.cs" },
                Portability.NormalizeDirectorySeparators(@"MetadataTests\EscapesOutputFilenames")
            )) {
                var filenames = test.Translate((tr) => {
                    return (from file in tr.OrderedFiles select file.Filename).ToArray();
                }, () => {
                    var configuration = MakeConfiguration();
                    configuration.FilenameEscapeRegex = "[^A-Za-z0-9 _]";
                    return configuration;
                });

                Assert.AreEqual(1, filenames.Length);

                foreach (var filename in filenames) {
                    Assert.IsTrue(Regex.IsMatch(filename, @"^([A-Za-z0-9 _]*)\.js$"), "Filename '{0}' does not match regex.", filename);
                    Console.WriteLine(filename);
                }
            }
        }

 public void StaticInitializersInInheritedClasses()
 {
     using (var test = new ComparisonTest(@"TestCases\StaticInitializersInInheritedClasses.cs"))
     {
         test.Run();
     }
 }

 public void StaticInitializersInGenericTypesSettingStaticFields()
 {
     using (var test = new ComparisonTest(@"TestCases\StaticInitializersInGenericTypesSettingStaticFields.cs"))
     {
         test.Run();
     }
 }

 public void StaticConstructors()
 {
     using (var test = new ComparisonTest(@"TestCases\GenericStaticConstructorOrdering.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\StaticConstructorOrdering.cs"))
         test.Run();
     using (var test = new ComparisonTest(@"TestCases\StaticInitializersInGenericTypesSettingStaticFields.cs"))
         test.Run();
 }

 public void StaticArrays()
 {
     using (var test = new ComparisonTest(@"TestCases\StaticArrayInitializer.cs"))
         test.Run();
 }

        private CompileResult RunComparisonTest(
            string filename, string[] stubbedAssemblies = null, TypeInfoProvider typeInfo = null, Action<string, string> errorCheckPredicate = null,
            List<string> failureList = null, string commonFile = null, bool shouldRunJs = true, AssemblyCache asmCache = null,
            Func<Configuration> makeConfiguration = null, Action<Exception> onTranslationFailure = null,
            string compilerOptions = ""
        )
        {
            CompileResult result = null;
            Console.WriteLine("// {0} ... ", Path.GetFileName(filename));
            filename = Portability.NormalizeDirectorySeparators(filename);

            try {
                var testFilenames = new List<string>() { filename };
                if (commonFile != null)
                    testFilenames.Add(commonFile);

                using (var test = new ComparisonTest(
                    EvaluatorPool,
                    testFilenames,
                    Path.Combine(
                        ComparisonTest.TestSourceFolder,
                        ComparisonTest.MapSourceFileToTestFile(filename)
                    ),
                    stubbedAssemblies, typeInfo, asmCache,
                    compilerOptions: compilerOptions
                )) {
                    result = test.CompileResult;

                    if (shouldRunJs) {
                        test.Run(makeConfiguration: makeConfiguration, onTranslationFailure: onTranslationFailure);
                    } else {
                        string js;
                        long elapsed;
                        try {
                            var csOutput = test.RunCSharp(new string[0], out elapsed);
                            test.GenerateJavascript(new string[0], out js, out elapsed, makeConfiguration, onTranslationFailure);

                            Console.WriteLine("generated");

                            if (errorCheckPredicate != null) {
                                errorCheckPredicate(csOutput, js);
                            }
                        } catch (Exception) {
                            Console.WriteLine("error");
                            throw;
                        }
                    }
                }
            } catch (Exception ex) {
                if (ex.Message == "JS test failed")
                    Debug.WriteLine(ex.InnerException);
                else
                    Debug.WriteLine(ex);

                if (failureList != null) {
                    failureList.Add(Path.GetFileNameWithoutExtension(filename));
                } else
                    throw;
            }

            return result;
        }

 public void ValueTypeMethods()
 {
     using (var test = new ComparisonTest(@"TestCases\ValueTypeMethods.cs"))
         test.Run();
 }

 public void MulticastDelegates()
 {
     using (var test = new ComparisonTest(@"TestCases\MulticastDelegates.cs"))
         test.Run();
 }

 public void HelloWorld()
 {
     using (var test = new ComparisonTest(@"TestCases\HelloWorld.cs")) {
         test.Run();
         test.Run("hello", "world");
     }
 }

 public void Goto()
 {
     using (var test = new ComparisonTest(@"TestCases\Goto.cs"))
         test.Run();
 }

 public void FaultBlock()
 {
     using (var test = new ComparisonTest(@"TestCases\FaultBlock.cs"))
         test.Run();
 }

 public void FannkuchRedux()
 {
     using (var test = new ComparisonTest(@"TestCases\FannkuchRedux.cs")) {
         test.Run();
         test.Run("10");
     }
 }