C# MockErrorReporter类代码示例

        internal Tuple<string, ICompilation, IMetadataImporter, MockErrorReporter> Compile(string source, bool includeLinq = false, bool expectErrors = false)
        {
            var sourceFile = new MockSourceFile("file.cs", source);
            var md = new MetadataImporter.ScriptSharpMetadataImporter(false);
            var n = new DefaultNamer();
            var er = new MockErrorReporter(!expectErrors);
            PreparedCompilation compilation = null;
            var rtl = new ScriptSharpRuntimeLibrary(md, er, n.GetTypeParameterName, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return new JsTypeReferenceExpression(t.ParentAssembly, md.GetTypeSemantics(t).Name); });
            var compiler = new Compiler.Compiler(md, n, rtl, er);

            var references = includeLinq ? new[] { Common.Mscorlib, Common.Linq } : new[] { Common.Mscorlib };
            compilation = compiler.CreateCompilation(new[] { sourceFile }, references, null);
            var compiledTypes = compiler.Compile(compilation);

            if (expectErrors) {
                Assert.That(er.AllMessages, Is.Not.Empty, "Compile should have generated errors");
                return Tuple.Create((string)null, compilation.Compilation, (IMetadataImporter)md, er);
            }

            er.AllMessagesText.Should().BeEmpty("Compile should not generate errors");

            var js = new OOPEmulator.ScriptSharpOOPEmulator(md, rtl, er).Rewrite(compiledTypes, compilation.Compilation);
            js = new GlobalNamespaceReferenceImporter().ImportReferences(js);

            string script = string.Join("", js.Select(s => OutputFormatter.Format(s, allowIntermediates: false)));

            if (Output == OutputType.GeneratedScript)
                Console.WriteLine(script);
            return Tuple.Create(script, compilation.Compilation, (IMetadataImporter)md, er);
        }

        public void CannotUseNotUsableTypeAsAGenericArgument()
        {
            var nc = new MockMetadataImporter { GetTypeSemantics = t => t.Name == "C1" ? TypeScriptSemantics.NotUsableFromScript() : TypeScriptSemantics.NormalType(t.Name) };
            var er = new MockErrorReporter(false);

            Compile(new[] {
            @"class C1 {}
            class C {
            public void F1<T>() {}
            public void M() {
            F1<C1>();
            }
            }" }, metadataImporter: nc, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("generic argument") && er.AllMessagesText[0].Contains("C1") && er.AllMessagesText[0].Contains("F1"));

            er = new MockErrorReporter(false);
            Compile(new[] {
            @"class C1 {}
            interface I1<T> {}
            class C {
            public void F1<T>() {}
            public void M() {
            F1<I1<I1<C1>>>();
            }
            }" }, metadataImporter: nc, errorReporter: er);
            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("generic argument") && er.AllMessagesText[0].Contains("C1") && er.AllMessagesText[0].Contains("F1"));
        }

        public void AssigningToFieldImplementedAsConstantIsAnError()
        {
            var er = new MockErrorReporter(false);
            Compile(new[] {
            @"class C {
            public int F1;
            public void M() {
            // BEGIN
            F1 = 1;
            // END
            }
            }" }, namingConvention: new MockNamingConventionResolver { GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name) }, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));

            er = new MockErrorReporter(false);
            Compile(new[] {
            @"class C {
            public int F1;
            public void M() {
            // BEGIN
            F1 += 1;
            // END
            }
            }" }, namingConvention: new MockNamingConventionResolver { GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name) }, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
        }

        public void CanCompileAsyncTaskGenericMethod()
        {
            UsingFiles(() => {
                File.WriteAllText(Path.GetFullPath("File1.cs"), @"
            using System.Threading.Tasks;
            public class C1 {
            public async Task<int> M() {
            var t = new Task(() => {});
            await t;
            return 0;
            }
            }");
                var options = new CompilerOptions {
                    References         = { new Reference(Common.MscorlibPath) },
                    SourceFiles        = { Path.GetFullPath("File1.cs") },
                    OutputAssemblyPath = Path.GetFullPath("Test.dll"),
                    OutputScriptPath   = Path.GetFullPath("Test.js")
                };
                var er = new MockErrorReporter();
                var driver = new CompilerDriver(er);
                var result = driver.Compile(options, false);

                Assert.That(result, Is.True);
                Assert.That(File.Exists(Path.GetFullPath("Test.dll")), Is.True, "Assembly should be written");
                Assert.That(File.Exists(Path.GetFullPath("Test.js")), Is.True, "Script should be written");
            }, "File1.cs", "Test.dll", "Test.js");
        }

        public void ChangingTheWarningLevelWorks()
        {
            UsingFiles(() => {
                File.WriteAllText(Path.GetFullPath("File.cs"), @"public class C1 { public void M() { var x = 0l; } }");
                var options = new CompilerOptions {
                    References         = { new Reference(Common.MscorlibPath) },
                    SourceFiles        = { Path.GetFullPath("File.cs") },
                    OutputAssemblyPath = Path.GetFullPath("Test.dll"),
                    OutputScriptPath   = Path.GetFullPath("Test.js"),
                };
                var er = new MockErrorReporter();
                var driver = new CompilerDriver(er);
                var result = driver.Compile(options, false);

                Assert.That(result, Is.True);
                Assert.That(er.AllMessages.Select(m => m.Code).ToList(), Is.EquivalentTo(new[] { 219, 78 }));
            }, "File.cs", "Test.dll", "Test.js");

            UsingFiles(() => {
                File.WriteAllText(Path.GetFullPath("File.cs"), @"public class C1 { public void M() { var x = 0l; } }");
                var options = new CompilerOptions {
                    References         = { new Reference(Common.MscorlibPath) },
                    SourceFiles        = { Path.GetFullPath("File.cs") },
                    OutputAssemblyPath = Path.GetFullPath("Test.dll"),
                    OutputScriptPath   = Path.GetFullPath("Test.js"),
                    WarningLevel       = 3,
                };
                var er = new MockErrorReporter();
                var driver = new CompilerDriver(er);
                var result = driver.Compile(options, false);

                Assert.That(result, Is.True);
                Assert.That(er.AllMessages.Select(m => m.Code), Is.EqualTo(new[] { 219 }));
            }, "File.cs", "Test.dll", "Test.js");
        }

        public void AnErrorIsIssuedIfTheMainMethodIsNotImplementedAsANormalMethod()
        {
            var type = CreateMockTypeDefinition("MyClass");
            var main = new Mock<IMethod>(MockBehavior.Strict);
            main.SetupGet(_ => _.DeclaringTypeDefinition).Returns(type);
            main.SetupGet(_ => _.Name).Returns("Main");
            main.SetupGet(_ => _.FullName).Returns("MyClass.Main");
            main.SetupGet(_ => _.Parameters).Returns(EmptyList<IParameter>.Instance);
            main.SetupGet(_ => _.Region).Returns(DomRegion.Empty);

            var er = new MockErrorReporter();

            Process(
                new[] {
                    new JsClass(type, JsClass.ClassTypeEnum.Class, null, null, null) {
                        StaticMethods = { new JsMethod(main.Object, "$Main", new string[0], JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Identifier("X")))) }
                    }
                },
                new MockScriptSharpMetadataImporter() { GetMethodSemantics = m => ReferenceEquals(m, main.Object) ? MethodScriptSemantics.InlineCode("X") : MethodScriptSemantics.NormalMethod("$" + m.Name) },
                er,
                main.Object
            );

            Assert.That(er.AllMessages, Has.Count.EqualTo(1));
            Assert.That(er.AllMessages.Any(m => m.Code == 7801 && (string)m.Args[0] == "MyClass.Main"));
        }

        public void CannotUseNotUsableTypeInATypeOfExpression()
        {
            var metadataImporter = new MockMetadataImporter { GetTypeSemantics = t => t.Name == "C1" ? TypeScriptSemantics.NotUsableFromScript() : TypeScriptSemantics.NormalType(t.Name) };
            var er = new MockErrorReporter(false);

            Compile(new[] {
            @"class C1 {}
            class C {
            public void M() {
            var t = typeof(C1);
            }
            }" }, metadataImporter: metadataImporter, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("typeof") && er.AllMessagesText[0].Contains("C1"));

            er = new MockErrorReporter(false);
            Compile(new[] {
            @"class C1 {}
            interface I1<T> {}
            class C {
            public void M() {
            var t= typeof(I1<I1<C1>>);
            }
            }" }, metadataImporter: metadataImporter, errorReporter: er);
            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("typeof") && er.AllMessagesText[0].Contains("C1"));
        }

 private void AssertCorrect(string code, string feature)
 {
     var er = new MockErrorReporter();
     Compile(new[] { code }, errorReporter: er, allowUnsupportedConstructs: false);
     Assert.That(er.AllMessages.Count, Is.EqualTo(1));
     Assert.That(er.AllMessages[0].Code, Is.EqualTo(7998));
     Assert.That(er.AllMessages[0].Args[0], Is.EqualTo(feature));
 }

        public void ConstructorsAreReportedAsJsonConstructors()
        {
            var compilation = new SimpleCompilation(new CSharpProjectContent());
            var md = new MetadataImporter.ScriptSharpMetadataImporter(false);
            var er = new MockErrorReporter(true);
            md.Prepare(new ITypeDefinition[0], compilation.MainAssembly, er);
            Assert.That(er.AllMessagesText, Is.Empty, "Prepare should not generate errors");

            var t = CreateType(compilation);

            var c = md.GetConstructorSemantics(DefaultResolvedMethod.GetDummyConstructor(compilation, t));
            Assert.That(c.Type, Is.EqualTo(ConstructorScriptSemantics.ImplType.Json));
        }

        protected string Process(IEnumerable<JsType> types, IScriptSharpMetadataImporter metadataImporter = null)
        {
            metadataImporter = metadataImporter ?? new MockScriptSharpMetadataImporter();

            IProjectContent proj = new CSharpProjectContent();
            proj = proj.AddAssemblyReferences(new[] { Common.Mscorlib });
            var comp = proj.CreateCompilation();
            var er = new MockErrorReporter(true);
            var obj = new OOPEmulator.ScriptSharpOOPEmulator(metadataImporter, er);
            Assert.That(er.AllMessages, Is.Empty, "Should not have errors");
            var rewritten = obj.Rewrite(types, comp);
            return string.Join("", rewritten.Select(s => OutputFormatter.Format(s, allowIntermediates: true)));
        }

        public void TransparentIdentiferIsValidJavascriptIdentifierStartingWithDollar()
        {
            var compilation = new SimpleCompilation(new CSharpProjectContent());
            var md = new MetadataImporter.ScriptSharpMetadataImporter(false);
            var er = new MockErrorReporter(true);
            md.Prepare(new ITypeDefinition[0], compilation.MainAssembly, er);
            Assert.That(er.AllMessagesText, Is.Empty, "Prepare should not generate errors");

            var t = CreateType(compilation, new[] { "<>Identifier" });

            var c = md.GetPropertySemantics(t.GetProperties().Single());
            Assert.That(c.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
            Assert.That(c.FieldName, Is.EqualTo("$Identifier"));
        }

        public void CannotAccessExpandedParamsParameter()
        {
            var er = new MockErrorReporter(false);

            Compile(new[] {
            @"class C1 {
            public void M(int i, int j, params int[] myParamArray) {
            int x = myParamArray[3];
            }
            }" }, metadataImporter: new MockMetadataImporter { GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name, expandParams: true) }, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("myParamArray") && er.AllMessagesText[0].Contains("expand") && er.AllMessagesText[0].Contains("param array"));
        }

        public void CannotPerformMethodGroupConversionOnMethodThatExpandsParams()
        {
            var er = new MockErrorReporter(false);

            Compile(new[] {
            @"class C1 {
            public void F(int x, int y, params int[] args) {}
            public void M() {
            System.Action<int, int, int[]> a = F;
            }
            }" }, namingConvention: new MockNamingConventionResolver { GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name, expandParams: m.Name == "F") }, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("C1.F") && er.AllMessagesText[0].Contains("expand") && er.AllMessagesText[0].Contains("param array"));
        }

        public void CannotAccessExpandedParamsParameterInExpressionLambda()
        {
            var er = new MockErrorReporter();

            Compile(new[] {
            @"public delegate int F(int x, int y, params int[] args);
            public class C {
            public void M() {
            F f = (a, b, myParamArray) => myParamArray[1];
            }
            }" }, metadataImporter: new MockMetadataImporter { GetDelegateSemantics = d => new DelegateScriptSemantics(expandParams: true) }, errorReporter: er);

            Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
            Assert.That(er.AllMessagesText[0].Contains("myParamArray") && er.AllMessagesText[0].Contains("expand") && er.AllMessagesText[0].Contains("param array"));
        }

 public void CanCompileProject()
 {
     var opts = ReadProject(@"C:\Projects\EngineGit\Project\Search\Search.Client\Search.Client.csproj", @"C:\Projects\EngineGit\Project");
     opts.DefineConstants.Add("CLIENT");
     try {
         var er = new MockErrorReporter();
         var d = new CompilerDriver(er);
         bool result = d.Compile(opts, false);
         Assert.That(result, Is.True);
         Assert.That(er.AllMessages, Is.Empty);
     }
     finally {
         try { File.Delete(Path.GetFullPath("output.dll")); } catch {}
         try { File.Delete(Path.GetFullPath("output.js")); } catch {}
     }
 }