private void TestInvariantGlobalization(BuildArgs buildArgs, bool?invariantGlobalization, RunHost host, string id, string extraProperties = "", bool?dotnetWasmFromRuntimePack = null) { string projectName = $"invariant_{invariantGlobalization?.ToString() ?? "unset"}"; if (invariantGlobalization != null) { extraProperties = $"{extraProperties}<InvariantGlobalization>{invariantGlobalization}</InvariantGlobalization>"; } buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, extraProperties); if (dotnetWasmFromRuntimePack == null) { dotnetWasmFromRuntimePack = !(buildArgs.AOT || buildArgs.Config == "Release"); } string programText = @" using System; using System.Globalization; // https://github.com/dotnet/runtime/blob/main/docs/design/features/globalization-invariant-mode.md#cultures-and-culture-data try { CultureInfo culture = new (""es-ES"", false); Console.WriteLine($""es-ES: Is Invariant LCID: {culture.LCID == CultureInfo.InvariantCulture.LCID}, NativeName: {culture.NativeName}""); } catch (CultureNotFoundException cnfe) { Console.WriteLine($""Could not create es-ES culture: {cnfe.Message}""); } Console.WriteLine($""CurrentCulture.NativeName: {CultureInfo.CurrentCulture.NativeName}""); return 42; "; BuildProject(buildArgs, initProject: () => File.WriteAllText(Path.Combine(_projectDir !, "Program.cs"), programText), id: id, dotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack, hasIcudt: invariantGlobalization == null || invariantGlobalization.Value == false); if (invariantGlobalization == true) { string output = RunAndTestWasmApp(buildArgs, expectedExitCode: 42, host: host, id: id); Assert.Contains("Could not create es-ES culture", output); Assert.Contains("CurrentCulture.NativeName: Invariant Language (Invariant Country)", output); } else { string output = RunAndTestWasmApp(buildArgs, expectedExitCode: 42, host: host, id: id); Assert.Contains("es-ES: Is Invariant LCID: False, NativeName: es (ES)", output); // ignoring the last line of the output which prints the current culture } } }
public void ConsoleBuildAndRun(string config) { string id = $"{config}_{Path.GetRandomFileName()}"; string projectFile = CreateWasmTemplateProject(id, "wasmconsole"); string projectName = Path.GetFileNameWithoutExtension(projectFile); updateProgramCS(); var buildArgs = new BuildArgs(projectName, config, false, id, null); buildArgs = ExpandBuildArgs(buildArgs); BuildProject(buildArgs, id: id, new BuildProjectOptions( DotnetWasmFromRuntimePack: true, CreateProject: false, HasV8Script: false, MainJS: "main.mjs", Publish: false, TargetFramework: "net7.0" )); AssertDotNetJsSymbols(Path.Combine(GetBinDir(config), "AppBundle"), fromRuntimePack: true); (int exitCode, string output) = RunProcess(s_buildEnv.DotNet, _testOutput, args: $"run --no-build -c {config} x y z", workingDir: _projectDir); Assert.Equal(0, exitCode); Assert.Contains("args[0] = x", output); Assert.Contains("args[1] = y", output); Assert.Contains("args[2] = z", output); }
public Export(IProject project, IFuse fuse, BuildArgs args) { var output = new Subject <string>(); LogMessages = output; var isMac = fuse.Platform == OS.Mac; ExportForAndroid = project.FilePath.CombineLatest(args.All, (path, allArgs) => Command.Enabled( action: () => fuse.RunFuse( "build", new[] { path.NativePath, "-t=android", "--run" }.Concat(allArgs).ToArray(), Observer.Create <string>(output.OnNext)))) .Switch(); ExportForIos = project.FilePath.CombineLatest(args.All, (path, allArgs) => Command.Create( isEnabled: isMac, action: () => fuse.RunFuse( "build", new[] { path.NativePath, "-t=ios", "--run" }.Concat(allArgs).ToArray(), Observer.Create <string>(output.OnNext)))) .Switch(); Menu = Menu.Item("Export for Android", ExportForAndroid) + Menu.Item("Export for iOS" + (!isMac ? " (Mac only)" : ""), ExportForIos); }
static void Build(BuildTarget target, bool isDebug = false) { BuildArgs args = new BuildArgs(); args.target = target; args.isDebug = isDebug; bool wait = false; var type = System.Reflection.Assembly.GetExecutingAssembly().GetType("CKEditor." + "ClientMacro"); if (type != null) { type.InvokeMember("SetPlatform", System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public, null, null, null); } if (EditorApplication.isCompiling) { var str = JsonUtility.ToJson(args); EditorPrefs.SetString("BuildParams", str); wait = true; } if (!wait) { AfterBuild(target, isDebug); } }
private void InjectTableVariables(StringBuilder sql, BuildArgs buildArgs, bool skipTimestampColumn) { if (buildArgs.Executable == null) { Throw(QueryTalkExceptionType.NullExecutableInnerException, null, null); } foreach (var argument in (buildArgs.Executable.Arguments).Where(a => a.DT.IsTableVariable())) { var view = (View)argument.Value; sql.NewLine(Text.Declare).S() .Append(argument.ParamName) .Append(Text._As_) .Append(Text.Table).S() .NewLine(Text.LeftBracket); BeginTableChainer.BuildFromView(sql, view, skipTimestampColumn); sql.NewLine(Text.RightBracket) .Terminate(); if (view.RowCount > 0) { BeginTableChainer.Fill(sql, argument.ParamName, view); } } }
public void GenerateCode() { buildArgs = new BuildArgs(); // load target type var classType = BindingEditorUtility.GetClassByName(settings.className).FirstOrDefault(); if (classType == null) { Debug.LogErrorFormat("Invalid class name {0}", settings.className); return; } // set target class buildArgs.type = classType; // get bindable properties var outputList = CodeTool.GetBindableProperties(); if (outputList == null) { Debug.LogError("Get bindable properties failed."); return; } SetupBuildArgs(outputList); WriteCode(); }
private static BuildArgs ParseCommandArgs(string[] args) { BuildArgs buildArgs = new BuildArgs(); for (int i = 0; i < args.Length; i++) { if (args[i] == "-outputPath") { buildArgs.OutputPath = args[i + 1]; } if (args[i] == "-revision") { buildArgs.Vision = args[i + 1]; } if (args[i] == "-buildType") { buildArgs.BuildType = args[i + 1]; } if (args[i] == "-FastBuild") { buildArgs.FastBuild = args[i + 1]; } } return(buildArgs); }
public PreviewOnDevice(IFuse fuse, IProject project, BuildArgs args) { var output = new Subject <string>(); LogMessages = output; var isMac = fuse.Platform == OS.Mac; var startedAndroidPreview = new Subject <Unit>(); MissingAndroidNotification.Create(fuse, startedAndroidPreview); PreviewAndroidApp = project.FilePath.CombineLatest(args.All, (path, allArgs) => Command.Enabled( action: () => { startedAndroidPreview.OnNext(Unit.Default); fuse.RunFuse( "preview", new[] { path.NativePath, "-t=android", "--quit-after-apk-launch" }.Concat(allArgs).ToArray(), Observer.Create <string>(output.OnNext)); })) .Switch(); PreviewIosApp = project.FilePath.CombineLatest(args.All, (path, allArgs) => Command.Create( isEnabled: isMac, action: () => fuse.RunFuse( "preview", new[] { path.NativePath, "-t=ios" }.Concat(allArgs).ToArray(), Observer.Create <string>(output.OnNext)))) .Switch(); Menu = Menu.Item("Preview on Android", PreviewAndroidApp) + Menu.Item("Preview on iOS" + (!isMac ? " (Mac only)" : ""), PreviewIosApp); }
public void NativeLibraryWithVariadicFunctions(BuildArgs buildArgs, RunHost host, string id) { string code = @" using System; using System.Runtime.InteropServices; public class Test { public static int Main(string[] args) { Console.WriteLine($""Main running""); if (args.Length > 0) { // We don't want to run this, because we can't call variadic functions Console.WriteLine($""sum_three: {sum_three(7, 14, 21)}""); Console.WriteLine($""sum_two: {sum_two(3, 6)}""); Console.WriteLine($""sum_one: {sum_one(5)}""); } return 42; } [DllImport(""variadic"", EntryPoint=""sum"")] public static extern int sum_one(int a); [DllImport(""variadic"", EntryPoint=""sum"")] public static extern int sum_two(int a, int b); [DllImport(""variadic"", EntryPoint=""sum"")] public static extern int sum_three(int a, int b, int c); }"; (buildArgs, string output) = BuildForVariadicFunctionTests(code, buildArgs with { ProjectName = $"variadic_{buildArgs.Config}_{id}" },
public void ProjectWithNativeReference(BuildArgs buildArgs, RunHost host, string id) { string projectName = $"AppUsingNativeLib-a"; buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, extraItems: "<NativeFileReference Include=\"native-lib.o\" />"); if (!_buildContext.TryGetBuildFor(buildArgs, out BuildProduct? _)) { InitPaths(id); if (Directory.Exists(_projectDir)) { Directory.Delete(_projectDir, recursive: true); } Utils.DirectoryCopy(Path.Combine(BuildEnvironment.TestAssetsPath, "AppUsingNativeLib"), _projectDir); File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "native-libs", "native-lib.o"), Path.Combine(_projectDir, "native-lib.o")); } BuildProject(buildArgs, id: id, new BuildProjectOptions(DotnetWasmFromRuntimePack: false)); string output = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 0, test: output => {}, host: host, id: id); Assert.Contains("print_line: 100", output); Assert.Contains("from pinvoke: 142", output); }
public void CheckThatSatelliteAssembliesAreNotAOTed(BuildArgs buildArgs, string id) { string projectName = $"check_sat_asm_not_aot"; buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, projectTemplate: s_resourcesProjectTemplate, extraProperties: $@" <EmccCompileOptimizationFlag>-O0</EmccCompileOptimizationFlag> <EmccLinkOptimizationFlag>-O0</EmccLinkOptimizationFlag>", extraItems: $"<EmbeddedResource Include=\"{BuildEnvironment.RelativeTestAssetsPath}resx\\*\" />"); BuildProject(buildArgs, id: id, new BuildProjectOptions( InitProject: () => CreateProgramForCultureTest(_projectDir !, $"{projectName}.words", "TestClass"), DotnetWasmFromRuntimePack: false)); var bitCodeFileNames = Directory.GetFileSystemEntries(Path.Combine(_projectDir !, "obj"), "*.dll.bc", SearchOption.AllDirectories) .Select(path => Path.GetFileName(path)) .ToArray(); // sanity check, in case we change file extensions Assert.Contains($"{projectName}.dll.bc", bitCodeFileNames); Assert.Empty(bitCodeFileNames.Where(file => file.EndsWith(".resources.dll.bc"))); }
static public void buildAfterTagetSwitch(BuildArgs args) { Debug.Log("buildAfterTagetSwitch"); buildOption = BuildOptions.None; //PlayerSettings.bundleIdentifier = args._bundleId; //PlayerSettings.bundleVersion = args._applicationVer; //PlayerSettings.shortBundleVersion = args._shortBundleVersion; EditorUserBuildSettings.development = args._isDevMode; if (args._isDevMode) { buildOption |= BuildOptions.Development; } Debug.Log("BuildAssetBundles"); //AssetBundleBuildPanel.BuildAssetBundles(); if (args._buildTarget == UnityEditor.BuildTarget.Android) { Publish.BuildAPK(false, false, false, args._package_filename + ".apk"); } else if (args._buildTarget == UnityEditor.BuildTarget.iOS) { BuildForIPhone(); } }
public void ResourcesFromProjectReference(BuildArgs buildArgs, bool nativeRelink, string?argCulture, string expectedOutput, RunHost host, string id) { string projectName = $"sat_asm_proj_ref"; bool dotnetWasmFromRuntimePack = !nativeRelink && !buildArgs.AOT; buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, projectTemplate: s_resourcesProjectTemplate, extraProperties: $"<WasmBuildNative>{(nativeRelink ? "true" : "false")}</WasmBuildNative>", extraItems: $"<ProjectReference Include=\"..\\LibraryWithResources\\LibraryWithResources.csproj\" />"); BuildProject(buildArgs, initProject: () => CreateProgramForCultureTest("LibraryWithResources.words", "LibraryWithResources.Class1"), dotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack, id: id); string output = RunAndTestWasmApp(buildArgs, expectedExitCode: 42, args: argCulture, host: host, id: id); Assert.Contains(expectedOutput, output); }
public void GetArgumentList() { for (var i = 0; i < _argStrings.Length; ++i) { CollectionAssert.AreEqual(_argLists[i], BuildArgs.GetArgumentList(_argStrings[i])); } }
protected void TestMain(string projectName, string programText, BuildArgs buildArgs, RunHost host, string id, string extraProperties = "", bool?dotnetWasmFromRuntimePack = null) { buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, extraProperties); if (dotnetWasmFromRuntimePack == null) { dotnetWasmFromRuntimePack = !(buildArgs.AOT || buildArgs.Config == "Release"); } BuildProject(buildArgs, id: id, new BuildProjectOptions( InitProject: () => File.WriteAllText(Path.Combine(_projectDir !, "Program.cs"), programText), DotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack)); RunAndTestWasmApp(buildArgs, expectedExitCode: 42, test: output => Assert.Contains("Hello, World!", output), host: host, id: id); } }
public void ResourcesFromMainAssembly(BuildArgs buildArgs, bool nativeRelink, string?argCulture, string expectedOutput, RunHost host, string id) { string projectName = $"sat_asm_from_main_asm"; bool dotnetWasmFromRuntimePack = !nativeRelink && !buildArgs.AOT; buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, projectTemplate: s_resourcesProjectTemplate, extraProperties: $"<WasmBuildNative>{(nativeRelink ? "true" : "false")}</WasmBuildNative>", extraItems: $"<EmbeddedResource Include=\"..\\resx\\*\" />"); BuildProject(buildArgs, initProject: () => CreateProgramForCultureTest($"{projectName}.words", "TestClass"), dotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack, id: id); string output = RunAndTestWasmApp( buildArgs, expectedExitCode: 42, args: argCulture, host: host, id: id); Assert.Contains(expectedOutput, output); }
static public void buildFromArgs(BuildArgs args) { Debug.Log("buildFromArgs"); if (args._buildTarget == EditorUserBuildSettings.activeBuildTarget) { buildAfterTagetSwitch(args); } else { #if UNITY_2017_1_OR_NEWER _isCanBuildAfterChangeBuildTarget = true; _args = args; #else EditorUserBuildSettings.activeBuildTargetChanged = delegate() { buildAfterTagetSwitch(args); }; #endif if (args._buildTarget == BuildTarget.Android) { EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Android, args._buildTarget); } else if (args._buildTarget == BuildTarget.iOS) { EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.iOS, args._buildTarget); } } }
public void PropertiesFromCsproj(BuildArgs buildArgs, RunHost host, string id) { buildArgs = buildArgs with { ProjectName = $"runtime_config_csproj_{buildArgs.Config}_{buildArgs.AOT}" }; buildArgs = ExpandBuildArgs(buildArgs, extraProperties: "<ThreadPoolMaxThreads>20</ThreadPoolMaxThreads>"); string programText = @" using System; using System.Runtime.CompilerServices; var config = AppContext.GetData(""System.Threading.ThreadPool.MaxThreads""); Console.WriteLine ($""System.Threading.ThreadPool.MaxThreads: {(string)config}""); return 42; "; BuildProject(buildArgs, id: id, new BuildProjectOptions( InitProject: () => { File.WriteAllText(Path.Combine(_projectDir !, "Program.cs"), programText); }, DotnetWasmFromRuntimePack: !(buildArgs.AOT || buildArgs.Config == "Release"))); RunAndTestWasmApp(buildArgs, expectedExitCode: 42, test: output => Assert.Contains("System.Threading.ThreadPool.MaxThreads: 20", output), host: host, id: id); } }
protected string Rebuild(bool nativeRelink, bool invariant, BuildArgs buildArgs, string id, string extraProperties = "", string extraBuildArgs = "", string?verbosity = null) { if (!_buildContext.TryGetBuildFor(buildArgs, out BuildProduct? product)) { throw new XunitException($"Test bug: could not get the build product in the cache"); } File.Move(product !.LogFile, Path.ChangeExtension(product.LogFile !, ".first.binlog")); buildArgs = buildArgs with { ExtraBuildArgs = $"{buildArgs.ExtraBuildArgs} {extraBuildArgs}" }; var newBuildArgs = GenerateProjectContents(buildArgs, nativeRelink, invariant, extraProperties); // key(buildArgs) being changed _buildContext.RemoveFromCache(product.ProjectDir); _buildContext.CacheBuild(newBuildArgs, product); if (buildArgs.ProjectFileContents != newBuildArgs.ProjectFileContents) { File.WriteAllText(Path.Combine(_projectDir !, $"{buildArgs.ProjectName}.csproj"), buildArgs.ProjectFileContents); } buildArgs = newBuildArgs; _testOutput.WriteLine($"{Environment.NewLine}Rebuilding with no changes ..{Environment.NewLine}"); (_, string output) = BuildProject(buildArgs, id: id, dotnetWasmFromRuntimePack: false, hasIcudt: !invariant, createProject: false, useCache: false, verbosity: verbosity); return(output); }
public void ResourcesFromMainAssembly(BuildArgs buildArgs, bool nativeRelink, string?argCulture, string expectedOutput, RunHost host, string id) { string projectName = $"sat_asm_from_main_asm"; // Release+publish defaults to native relinking bool dotnetWasmFromRuntimePack = !nativeRelink && !buildArgs.AOT && buildArgs.Config != "Release"; buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, projectTemplate: s_resourcesProjectTemplate, extraProperties: nativeRelink ? $"<WasmBuildNative>true</WasmBuildNative>" : string.Empty); BuildProject(buildArgs, id: id, new BuildProjectOptions( InitProject: () => { Utils.DirectoryCopy(Path.Combine(BuildEnvironment.TestAssetsPath, "resx"), Path.Combine(_projectDir !, "resx")); CreateProgramForCultureTest(_projectDir !, $"{projectName}.resx.words", "TestClass"); }, DotnetWasmFromRuntimePack: dotnetWasmFromRuntimePack)); string output = RunAndTestWasmApp( buildArgs, expectedExitCode: 42, args: argCulture, host: host, id: id); Assert.Contains(expectedOutput, output); }
public void PropertiesFromRuntimeConfigJson(BuildArgs buildArgs, RunHost host, string id) { buildArgs = buildArgs with { ProjectName = $"runtime_config_{buildArgs.Config}_{buildArgs.AOT}" }; buildArgs = ExpandBuildArgs(buildArgs); string programText = @" using System; using System.Runtime.CompilerServices; var config = AppContext.GetData(""test_runtimeconfig_json""); Console.WriteLine ($""test_runtimeconfig_json: {(string)config}""); return 42; "; string runtimeConfigTemplateJson = @" { ""configProperties"": { ""abc"": ""4"", ""test_runtimeconfig_json"": ""25"" } }"; BuildProject(buildArgs, initProject: () => { File.WriteAllText(Path.Combine(_projectDir !, "Program.cs"), programText); File.WriteAllText(Path.Combine(_projectDir !, "runtimeconfig.template.json"), runtimeConfigTemplateJson); },
static public void buildAfterTagetSwitch(BuildArgs args) { Debug.Log("buildAfterTagetSwitch"); PlayerSettings.applicationIdentifier = args._bundleId; PlayerSettings.bundleVersion = args._applicationVer; //PlayerSettings.shortBundleVersion = args._shortBundleVersion; if (args._buildTarget == UnityEditor.BuildTarget.Android) { EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTarget.Android); { //buildAB Publish.BuildAPK(false, true, false, args._package_filename + ".apk"); } } else if (args._buildTarget == UnityEditor.BuildTarget.iOS) { EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTarget.iOS); //ExportAssetBundles.Publish_Dev_OnKeyAB(BuildTarget.iOS, false); BuildForIPhone(); } }
public void IntermediateBitcodeToObjectFilesAreNotLLVMIR(BuildArgs buildArgs, string id) { string printFileTypeTarget = @" <Target Name=""PrintIntermediateFileType"" AfterTargets=""WasmNestedPublishApp""> <Exec Command=""wasm-dis $(_WasmIntermediateOutputPath)System.Private.CoreLib.dll.o -o $(_WasmIntermediateOutputPath)wasm-dis-out.txt"" EnvironmentVariables=""@(EmscriptenEnvVars)"" IgnoreExitCode=""true""> <Output TaskParameter=""ExitCode"" PropertyName=""ExitCode"" /> </Exec> <Message Text="" ** wasm-dis exit code: $(ExitCode) "" Importance=""High"" /> </Target> "; string projectName = $"bc_to_o_{buildArgs.Config}"; buildArgs = buildArgs with { ProjectName = projectName }; buildArgs = ExpandBuildArgs(buildArgs, insertAtEnd: printFileTypeTarget); (_, string output) = BuildProject(buildArgs, id: id, new BuildProjectOptions( InitProject: () => File.WriteAllText(Path.Combine(_projectDir !, "Program.cs"), s_mainReturns42), DotnetWasmFromRuntimePack: false)); if (!output.Contains("** wasm-dis exit code: 0")) { throw new XunitException($"Expected to successfully run wasm-dis on System.Private.CoreLib.dll.o ." + " It might fail if it was incorrectly compiled to a bitcode file, instead of wasm."); } }
static void commandLineBuild() { BuildArgs ba = parseCommandLine(); buildFromArgs(ba); EditorApplication.Exit(0); }
public static void PullFromDevon() { Console.WriteLine("DevonCommandLine PullFromDevon"); var buildArgs = new BuildArgs("Devon", 0, 0); if (buildArgs.CmdLineArgs.ContainsKey("devonOAuth")) { bool done = false; DevonAPI.PullFromDevon(Game.ForceVision.ToString(), buildArgs.CmdLineArgs["devonOAuth"].ToString(), (result) => { Console.WriteLine("Pull Result: " + result); done = true; }); // need to wait for async operation above to finish because when run from command line Unity will exit after this command. while (!done) { System.Threading.Thread.Sleep(10); UnityEditor.EditorApplication.update(); } } else { Console.WriteLine("Error: devonOAuth must be specified"); throw new Exception("DevonCommandLine failure: -devonOAuth=<auth> must be specified"); } }
public void ConsolePublishAndRun(string config, bool aot) { string id = $"{config}_{Path.GetRandomFileName()}"; string projectFile = CreateWasmTemplateProject(id, "wasmconsole"); string projectName = Path.GetFileNameWithoutExtension(projectFile); string programText = "" " using System; for (int i = 0; i < args.Length; i ++) Console.WriteLine ($" args[{ i }] = { args[i] } "); " ""; File.WriteAllText(Path.Combine(_projectDir !, "Program.cs"), programText); if (aot) { AddItemsPropertiesToProject(projectFile, "<RunAOTCompilation>true</RunAOTCompilation>"); } var buildArgs = new BuildArgs(projectName, config, aot, id, null); buildArgs = ExpandBuildArgs(buildArgs); bool expectRelinking = config == "Release" || aot; BuildProject(buildArgs, id: id, new BuildProjectOptions( DotnetWasmFromRuntimePack: !expectRelinking, CreateProject: false, HasV8Script: false, MainJS: "main.mjs", Publish: true, TargetFramework: "net7.0", UseCache: false)); AssertDotNetJsSymbols(Path.Combine(GetBinDir(config), "AppBundle"), fromRuntimePack: !expectRelinking); // FIXME: pass envvars via the environment, once that is supported string runArgs = $"run --no-build -c {config}"; if (aot) { runArgs += $" --setenv=MONO_LOG_MASK=aot --setenv=MONO_LOG_LEVEL=debug"; } runArgs += " x y z"; var res = new RunCommand(s_buildEnv, _testOutput, label: id) .WithWorkingDirectory(_projectDir !) .ExecuteWithCapturedOutput(runArgs) .EnsureSuccessful(); if (aot) { Assert.Contains($"AOT: image '{Path.GetFileNameWithoutExtension(projectFile)}' found", res.Output); } Assert.Contains("args[0] = x", res.Output); Assert.Contains("args[1] = y", res.Output); Assert.Contains("args[2] = z", res.Output); }
public void ArgumentRoundTrip1() { foreach (var argList in _argLists) { var argString = BuildArgs.GetArgumentString(argList); CollectionAssert.AreEqual(argList, BuildArgs.GetArgumentList(argString)); } }
protected string RunAndTestWasmApp(BuildArgs buildArgs, RunHost host, string id, Action <string>?test = null, string?buildDir = null, int expectedExitCode = 0, string?args = null, Dictionary <string, string>?envVars = null) { buildDir ??= _projectDir; envVars ??= new(); envVars["XHARNESS_DISABLE_COLORED_OUTPUT"] = "true"; if (buildArgs.AOT) { envVars["EMSDK_PATH"] = s_emsdkPath; envVars["MONO_LOG_LEVEL"] = "debug"; envVars["MONO_LOG_MASK"] = "aot"; } string bundleDir = Path.Combine(GetBinDir(baseDir: buildDir, config: buildArgs.Config), "AppBundle"); (string testCommand, string extraXHarnessArgs) = host switch { RunHost.V8 => ("wasm test", "--js-file=runtime.js --engine=V8 -v trace"), _ => ("wasm test-browser", $"-v trace -b {host}") }; string testLogPath = Path.Combine(_logPath, host.ToString()); string output = RunWithXHarness( testCommand, testLogPath, buildArgs.ProjectName, bundleDir, _testOutput, envVars: envVars, expectedAppExitCode: expectedExitCode, extraXHarnessArgs: extraXHarnessArgs, appArgs: args); if (buildArgs.AOT) { Assert.Contains("AOT: image 'System.Private.CoreLib' found.", output); Assert.Contains($"AOT: image '{buildArgs.ProjectName}' found.", output); } else { Assert.DoesNotContain("AOT: image 'System.Private.CoreLib' found.", output); Assert.DoesNotContain($"AOT: image '{buildArgs.ProjectName}' found.", output); } if (test != null) { test(output); } return(output); }
static void OnGloabalBuild(BuildArgs args) { var handler = GloabalBuild; if (handler != null) { handler(null, args); } }
protected virtual void OnDobuilding(BuildArgs args) { var handler = Dobuilding; if (handler != null) { handler(this, args); } }
/// <summary> /// Handles the Selecting event of the tabControl1 control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.Windows.Forms.TabControlCancelEventArgs"/> instance containing the event data.</param> private void TabControl1_Selecting(object sender, TabControlCancelEventArgs e) { using(AdvancedMessageBox advbox = new AdvancedMessageBox("Are you sure you want to cancel current operation?", ReportStatus.Information, true)) { if (DialogResult.OK == advbox.ShowDialog()) { this.ResetTreeViewNodes(this.tvCheckList.Nodes["10"]); this.ResetTreeViewNodes(this.tvCheckList.Nodes["20"]); this.progressBar.Value = this.progressBar.Minimum; this.btnViewBuildLog.Enabled = this.btnViewDeployLog.Enabled = this.btnViewTFLog.Enabled = false; this.toolStripStatusLabel.Text = string.Empty; this.rollbackVersionToLog = string.Empty; this.pkgNameForLocalDeployment = string.Empty; this.buildArgs = null; switch (e.TabPageIndex) { case 0: this.txtConfigPath.Text = this.txtPackagePath.Text = string.Empty; break; case 1: this.cbxServerName.SelectedIndex = -1; txtTFSLabelName.Text = txtTFSDefaultCollection.Text = txtSolutionName.Text = string.Empty; btnLoadSolutions.Enabled = false; this.btnLoadTFSlabel.Enabled = false; break; default: break; } } else { e.Cancel = true; } } this.BringToFront(); }
/// <summary> /// Handles the Click event of the btnDeploy control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> private void BtnDeploy_Click(object sender, EventArgs e) { try { bool isLocalDeployment = this.tabControl1.SelectedTab.Name.Equals("tabLocalDeployment"); this.Text = this.Text.Contains(this.txtSolutionName.Text) ? this.Text : string.Concat(this.Text, "-[", this.txtSolutionName.Text, "]"); this.progressBar.Maximum = this.progressBar.Step * this.totalStepsIdentified; // number of task this.btnViewBuildLog.Enabled = this.btnViewDeployLog.Enabled = this.btnViewTFLog.Enabled = false; if (!isLocalDeployment) { this.buildArgs = this.PrepareBuildArgs(); this.buildArgs.Validate(); //replace with new name this.buildArgs.ModifiedSolutionName = string.Concat(this.buildArgs.SolutionName, "-", this.buildArgs.Version); } else { if (string.IsNullOrEmpty(this.txtPackagePath.Text) || !File.Exists(this.txtPackagePath.Text)) { throw new ArgumentException("Invalid package file path", "Package Path"); } if (string.IsNullOrEmpty(this.txtConfigPath.Text) || !File.Exists(this.txtConfigPath.Text)) { throw new ArgumentException("Invalid configuration file path", "Config Path"); } // save this in form variable to avoid STA this.pkgNameForLocalDeployment = Path.GetFileNameWithoutExtension(this.txtPackagePath.Text); } this.cloudArgs = this.PrepareCloudArgs(); // validate the publish setting path and subscriptions combo if (string.IsNullOrEmpty(this.txtPublishSettingsFilePath.Text) || !File.Exists(this.txtPublishSettingsFilePath.Text)) { throw new ArgumentException("Invalid publish settings file path", "Publish Settings File"); } if (this.cbxSubscriptions.SelectedIndex == -1) { throw new ArgumentException("Atleast one subscriptions should be selected", "Subscriptions"); } this.cloudArgs.Validate(); this.ResetTreeViewNodes(this.tvCheckList.Nodes["10"]); this.ResetTreeViewNodes(this.tvCheckList.Nodes["20"]); this.progressBar.Value = this.progressBar.Minimum; if (!this.backgroundWorker.IsBusy) { this.SetUserActionOnFrom(false); this.backgroundWorker.RunWorkerAsync(isLocalDeployment); } } catch (ArgumentNullException argEx) { argEx.ShowUIException(); } catch (ArgumentException argEx) { argEx.ShowUIException(); } }
protected virtual void OnDobuilding(BuildArgs args) { var handler = Dobuilding; if(handler != null) { handler(this, args); } }
static void OnGloabalBuild(BuildArgs args) { var handler = GloabalBuild; if(handler != null) { handler(null, args); } }
void BobDobuilding(object sender, BuildArgs args) { _i++; }