Exemple #1
0
        public async Task CompilingCode_ThatDoesCompile_CompilesLoadableCode()
        {
            var playground = PlaygroundWorkspace.FromSource(SourceCodeKind.Regular, SampleCode.CompilerTest);

            CompilerResult result = await playground.CompileAsync();

            Assert.IsTrue(result.Success);

            CollectionAssert.IsEmpty(result.Diagnostics);

            if (result.Success)
            {
                Assembly assembly = AppDomain.CurrentDomain.Load(result.Assembly);

                Type[] sourceTypes = assembly.GetTypes();

                Type       sourceType   = sourceTypes.Single();
                MethodInfo main         = sourceType.GetMethod("Sample");
                var        invokeResult = main.Invoke(null, new object[] { new List <string> {
                                                                               "asdf1", "asdf"
                                                                           } });

                Assert.IsAssignableFrom <string>(invokeResult);
                Assert.AreEqual("asdf1, asdf, From Source", invokeResult);
            }
        }
Exemple #2
0
        public async Task GetDiagnostics_ForCodeThatProducesWarnings_ReturnsWarnings()
        {
            var code = SampleCode.WarningsTest;

            var workspace = PlaygroundWorkspace.FromSource(SourceCodeKind.Regular, code, 0);

            IReadOnlyCollection <Diagnostic> diagnostics = await workspace.GetDiagnosticsAsync();

            Assert.AreEqual(1, diagnostics.Count);
            Assert.AreEqual(DiagnosticSeverity.Warning, diagnostics.First().Severity);
        }
        private static async Task Main()
        {
            WriteLine("Creating sandbox from C# script:");
            WriteLine();
            WriteLine(SampleScript.HelloWorld);
            WriteLine();

            var playground = PlaygroundWorkspace.FromSource(SourceCodeKind.Script, SampleScript.HelloWorld, 26);

            using (var analyser = new Analyser(playground))
            {
                await Tokenize(analyser);

                WriteLine();

                await Diagnostics(analyser);

                WriteLine();

                (var line, var column) = PositionConverter.PositionToRowColumn(playground.EditingFile.EditorPosition.Value, playground.EditingFile.RawContents);

                WriteLine($"Intellisense at {playground.EditingFile.EditorPosition} (line {line}, column {column}): ");

                using (UseColor(ConsoleColor.Cyan))
                {
                    await Autocomplete(analyser);
                }
                WriteLine();

                WriteLine($"Compiling and executing...");
                WriteLine(new string('-', 50));
                WriteLine();

                using (UseColor(ConsoleColor.Cyan))
                {
                    await analyser.CompileAndRunScript();
                }

                WriteLine();
                WriteLine(new string('-', 50));
            }

            WriteLine();

            WriteLine($"Press {nameof(ConsoleKey.Enter)} to exit");
            UntilEnterPressed();
        }
Exemple #4
0
        public async Task Autocomplete_WithCollectionAndPrefix_GetsFilteredAutocomplete()
        {
            var playground = PlaygroundWorkspace.FromSource(SourceCodeKind.Regular, SampleCode.CompilerTest, 174);

            IEnumerable <string> results;

            using (var autoComplete = new AutoCompleteWorkspaceService(playground))
            {
                results = await GetAutocomplete(autoComplete);
            }

            var expected = new[]
            {
                "Add",
                "AddRange"
            };

            CollectionAssert.AreEqual(expected, results);
        }
Exemple #5
0
        public async Task CompilingScript_ThatDoesCompile_CompilesLoadableCode()
        {
            var playground = PlaygroundWorkspace.FromSource(SourceCodeKind.Script, SampleScript.HelloWorld);

            CompilerResult result = await playground.CompileAsync();

            Assert.IsTrue(result.Success);

            CollectionAssert.IsEmpty(result.Diagnostics);

            if (result.Success)
            {
                Assembly assembly = AppDomain.CurrentDomain.Load(result.Assembly);

                var        scriptType   = assembly.GetType(Runner.ScriptTypeName);
                MethodInfo main         = scriptType.GetMethod(Runner.ScriptEntryPointName, Runner.ScriptEntryPointFlags);
                var        invokeResult = main.Invoke(null, new object[0]);

                Assert.AreEqual(null, invokeResult);
            }
        }