예제 #1
0
        public void SingleJobTest()
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(typeof(SingleJobTestSystem));

            var forEachDescriptionConstruction = LambdaJobDescriptionConstruction.FindIn(methodToAnalyze).Single();

            var icm = forEachDescriptionConstruction.InvokedConstructionMethods;

            Assert.AreEqual(LambdaJobDescriptionKind.Job, forEachDescriptionConstruction.Kind);

            CollectionAssert.AreEqual(new[]
            {
                nameof(LambdaJobDescriptionConstructionMethods.WithBurst),
                nameof(LambdaJobDescriptionConstructionMethods.WithName),
                nameof(LambdaSingleJobDescriptionConstructionMethods.WithCode),
            }, icm.Select(i => i.MethodName));

            CollectionAssert.AreEqual(new[]
            {
                3,
                1,
                1,
            }, icm.Select(i => i.Arguments.Length));

            Assert.AreEqual("MyJobName", icm[1].Arguments[0]);
        }
        protected override void AssertProducesInternal(
            Type systemType,
            DiagnosticType type,
            string[] shouldContains,
            bool useFailResolver = false)
        {
            var methodToAnalyze    = MethodDefinitionForOnlyMethodOf(systemType);
            var diagnosticMessages = new List <DiagnosticMessage>();

            try
            {
                foreach (var forEachDescriptionConstruction in LambdaJobDescriptionConstruction.FindIn(methodToAnalyze))
                {
                    var(_, rewriteMessages) = LambdaJobsPostProcessor.Rewrite(methodToAnalyze, forEachDescriptionConstruction);
                    diagnosticMessages.AddRange(rewriteMessages);
                }
            }
            catch (FoundErrorInUserCodeException exc)
            {
                diagnosticMessages.AddRange(exc.DiagnosticMessages);
            }

            Assert.AreEqual(1, diagnosticMessages.Count);
            Assert.AreEqual(type, diagnosticMessages[0].DiagnosticType);

            foreach (var str in shouldContains)
            {
                Assert.That(diagnosticMessages[0].MessageData.Contains(str), $"Error message \"{diagnosticMessages[0].MessageData}\" does not contain \"{str}\".");
            }

            AssertDiagnosticHasSufficientFileAndLineInfo(diagnosticMessages);
        }
예제 #3
0
        public void EntitiesForEachTest()
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(typeof(WithForEachSystem));

            var forEachDescriptionConstruction = LambdaJobDescriptionConstruction.FindIn(methodToAnalyze).Single();

            var icm = forEachDescriptionConstruction.InvokedConstructionMethods;

            CollectionAssert.AreEqual(new[]
            {
                nameof(LambdaJobQueryConstructionMethods.WithEntityQueryOptions),
                nameof(LambdaJobDescriptionConstructionMethods.WithBurst),
                nameof(LambdaJobQueryConstructionMethods.WithNone),
                nameof(LambdaJobQueryConstructionMethods.WithChangeFilter),
                nameof(LambdaJobDescriptionConstructionMethods.WithName),
                nameof(LambdaForEachDescriptionConstructionMethods.ForEach),
            }, icm.Select(i => i.MethodName));


            CollectionAssert.AreEqual(new[]
            {
                1,
                3,
                0,
                0,
                1,
                1,
            }, icm.Select(i => i.Arguments.Length));

            Assert.AreEqual("MyJobName", icm[4].Arguments[0]);
            CollectionAssert.AreEqual(new[] { nameof(Translation), nameof(Velocity) }, icm[3].TypeArguments.Select(t => t.Name));

            Assert.AreEqual(EntityQueryOptions.IncludePrefab, (EntityQueryOptions)icm[0].Arguments.Single());
        }
        protected void AssertProducesNoError(Type systemType)
        {
            Assert.DoesNotThrow(() =>
            {
                var assemblyDefinition = AssemblyDefinitionFor(systemType);
                var testSystemType     = assemblyDefinition.MainModule
                                         .GetAllTypes()
                                         .Where(TypeDefinitionExtensions.IsComponentSystem)
                                         .FirstOrDefault(t => t.Name == systemType.Name);

                foreach (var methodToAnalyze in testSystemType.Methods.ToList())
                {
                    foreach (var forEachDescriptionConstruction in LambdaJobDescriptionConstruction.FindIn(methodToAnalyze))
                    {
                        LambdaJobsPostProcessor.Rewrite(methodToAnalyze, forEachDescriptionConstruction, null);
                    }
                }

                // Write out assembly to memory stream
                // Missing ImportReference errors for types only happens here.
                var pe  = new MemoryStream();
                var pdb = new MemoryStream();
                var writerParameters = new WriterParameters
                {
                    SymbolWriterProvider = new PortablePdbWriterProvider(), SymbolStream = pdb, WriteSymbols = true
                };
                assemblyDefinition.Write(pe, writerParameters);
            });
        }
예제 #5
0
        public void WithReadOnlyCapturedVariableTest()
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(typeof(WithReadOnlyCapturedVariable));
            var description     = LambdaJobDescriptionConstruction.FindIn(methodToAnalyze).Single();
            var withReadOnly    = description.InvokedConstructionMethods.Single(m => m.MethodName == nameof(LambdaJobDescriptionConstructionMethods.WithReadOnly));

            Assert.IsInstanceOf <FieldDefinition>(withReadOnly.Arguments.Single());
        }
예제 #6
0
        public void DoesNotCaptureTest()
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(typeof(WithCodeThatDoesNotCaptureSystem));

            var icm = LambdaJobDescriptionConstruction.FindIn(methodToAnalyze).Single().InvokedConstructionMethods;

            CollectionAssert.AreEqual(new[]
            {
                nameof(LambdaForEachDescriptionConstructionMethods.ForEach),
            }, icm.Select(i => i.MethodName));
        }
예제 #7
0
        public void WithReadOnlyCapturedVariableFromTwoScopesTest()
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(typeof(WithReadOnlyCapturedVariableFromTwoScopes));
            var description     = LambdaJobDescriptionConstruction.FindIn(methodToAnalyze).Single();

            var withReadOnlyMethods = description.InvokedConstructionMethods.Where(m => m.MethodName == nameof(LambdaJobDescriptionConstructionMethods.WithReadOnly));

            Assert.AreEqual(2, withReadOnlyMethods.Count());
            foreach (var withReadOnly in withReadOnlyMethods)
            {
                Assert.IsInstanceOf <FieldDefinition>(withReadOnly.Arguments.Single());
            }
        }
예제 #8
0
        void AssertProducesInternal(Type systemType, DiagnosticType type, string[] shouldContains)
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(systemType);
            var errors          = new List <DiagnosticMessage>();

            try
            {
                foreach (var forEachDescriptionConstruction in LambdaJobDescriptionConstruction.FindIn(methodToAnalyze))
                {
                    LambdaJobsPostProcessor.Rewrite(methodToAnalyze, forEachDescriptionConstruction, errors);
                }
            }
            catch (FoundErrorInUserCodeException exc)
            {
                errors.AddRange(exc.DiagnosticMessages);
            }

            Assert.AreEqual(type, errors[0].DiagnosticType);
            string diagnostic = errors.Select(dm => dm.MessageData).SeparateByComma();

            foreach (var s in shouldContains)
            {
                StringAssert.Contains(s, diagnostic);
            }

            if (!diagnostic.Contains(".cs"))
            {
                Assert.Fail("Diagnostic message had no file info: " + diagnostic);
            }

            var match = Regex.Match(diagnostic, "\\.cs:?\\((?<line>.*?),(?<column>.*?)\\)");

            if (!match.Success)
            {
                Assert.Fail("Diagnostic message had no line info: " + diagnostic);
            }


            var line = int.Parse(match.Groups["line"].Value);

            if (line > 1000)
            {
                Assert.Fail("Unreasonable line number in errormessage: " + diagnostic);
            }
        }
        void AssertProducesInternal(Type systemType, DiagnosticType type, string[] shouldContains)
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(systemType);
            var errors          = new List <DiagnosticMessage>();

            try
            {
                foreach (var forEachDescriptionConstruction in LambdaJobDescriptionConstruction.FindIn(methodToAnalyze))
                {
                    LambdaJobsPostProcessor.Rewrite(methodToAnalyze, forEachDescriptionConstruction, errors);
                }
            }
            catch (FoundErrorInUserCodeException exc)
            {
                errors.AddRange(exc.DiagnosticMessages);
            }

            Assert.AreEqual(type, errors[0].DiagnosticType);


            AssertDiagnosticHasSufficientFileAndLineInfo(errors);
        }
예제 #10
0
        protected void RunTest(Type type)
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(type);
            var forEachDescriptionConstructions         = LambdaJobDescriptionConstruction.FindIn(methodToAnalyze);
            JobStructForLambdaJob jobStructForLambdaJob = null;

            foreach (var forEachDescriptionConstruction in forEachDescriptionConstructions)
            {
                jobStructForLambdaJob = LambdaJobsPostProcessor.Rewrite(methodToAnalyze, forEachDescriptionConstruction, null);
            }

            _methodIL = new StringBuilder();
            if (methodToAnalyze != null)
            {
                foreach (var instruction in methodToAnalyze.Body.Instructions)
                {
                    _methodIL.AppendLine(instruction.ToString());
                }
            }

            RunTest(jobStructForLambdaJob.TypeDefinition.DeclaringType);
        }
예제 #11
0
        protected void AssertProducesError(Type systemType, params string[] shouldContains)
        {
            var methodToAnalyze   = MethodDefinitionForOnlyMethodOf(systemType);
            var userCodeException = Assert.Throws <FoundErrorInUserCodeException>(() =>
            {
                foreach (var forEachDescriptionConstruction in LambdaJobDescriptionConstruction.FindIn(methodToAnalyze))
                {
                    LambdaJobsPostProcessor.Rewrite(methodToAnalyze, forEachDescriptionConstruction);
                }
            });

            foreach (var s in shouldContains)
            {
                StringAssert.Contains(s, userCodeException.ToString());
            }

            if (!userCodeException.ToString().Contains(".cs"))
            {
                Assert.Fail("Diagnostic message had no file info: " + userCodeException);
            }

            var match = Regex.Match(userCodeException.ToString(), "\\.cs:?\\((?<line>.*?),(?<column>.*?)\\)");

            if (!match.Success)
            {
                Assert.Fail("Diagnostic message had no line info: " + userCodeException);
            }


            var line = int.Parse(match.Groups["line"].Value);

            if (line > 1000)
            {
                Assert.Fail("Unreasonable line number in errormessage: " + userCodeException);
            }
        }
예제 #12
0
        public void RunInsideLoopCapturingLoopConditionTest()
        {
            var methodToAnalyze = MethodDefinitionForOnlyMethodOf(typeof(RunInsideLoopCapturingLoopCondition));

            LambdaJobDescriptionConstruction.FindIn(methodToAnalyze).Single();
        }