public void ExplictStripOption_ThirdPartyLibrary_AndWarnsIfSo(bool?strip, bool shouldStrip)
        {
            MMPTests.RunMMPTest(tmpDir => {
                string originalLocation   = Path.Combine(Configuration.SourceRoot, "tests", "test-libraries", "libtest-fat.macos.dylib");
                string newLibraryLocation = Path.Combine(tmpDir, "libTest.dylib");
                File.Copy(originalLocation, newLibraryLocation);

                TI.UnifiedTestConfig test = CreateStripTestConfig(strip, tmpDir, $" --native-reference=\"{newLibraryLocation}\"");
                test.Release = true;

                var testResult  = TI.TestUnifiedExecutable(test);
                var bundleDylib = Path.Combine(test.BundlePath, "Contents", "MonoBundle", "libTest.dylib");
                Assert.That(bundleDylib, Does.Exist, "libTest.dylib presence in app bundle");

                var architectures = MachO.GetArchitectures(bundleDylib);
                if (shouldStrip)
                {
                    Assert.AreEqual(1, architectures.Count, "libTest.dylib should only contain 1 architecture");
                    Assert.AreEqual(Abi.x86_64, architectures [0], "libTest.dylib should be x86_64");
                    testResult.Messages.AssertWarning(2108, "libTest.dylib was stripped of architectures except x86_64 to comply with App Store restrictions. This could break existing codesigning signatures. Consider stripping the library with lipo or disabling with --optimize=-trim-architectures");
                }
                else
                {
                    Assert.AreEqual(2, architectures.Count, "libTest.dylib should contain 2+ architectures");
                    Assert.That(architectures, Is.EquivalentTo(new Abi [] { Abi.i386, Abi.x86_64 }), "libTest.dylib should be x86_64 + i386");
                    testResult.Messages.AssertWarningCount(1);                      // dylib ([...]/xamarin-macios/tests/mmptest/bin/Debug/tmp-test-dir/Xamarin.MMP.Tests.MMPTests.RunMMPTest47/bin/Release/UnifiedExample.app/Contents/MonoBundle/libTest.dylib) was built for newer macOS version (10.11) than being linked (10.9)
                }
            });
        }
        public void Unified_WithNativeReferences_InMainProjectWorks()
        {
            MMPTests.RunMMPTest(tmpDir => {
                // Could be any dylib not in /System
                const string SystemLibPath = "/Library/Frameworks/Mono.framework/Versions/Current/lib/libsqlite3.0.dylib";

                TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
                {
                    ItemGroup = CreateSingleNativeRef(SystemLibPath, "Dynamic")
                };
                NativeReferenceTestCore(tmpDir, test, "Unified_WithNativeReferences_InMainProjectWorks - System", "libsqlite3.0.dylib", true);

                test.ItemGroup = CreateSingleNativeRef(Path.GetFullPath(SimpleDylibPath), "Dynamic");
                NativeReferenceTestCore(tmpDir, test, "Unified_WithNativeReferences_InMainProjectWorks - Local", "SimpleClassDylib.dylib", true);

                test.ItemGroup = CreateSingleNativeRef(Path.GetFullPath(SimpleStaticPath), "Static");
                NativeReferenceTestCore(tmpDir, test, "Unified_WithNativeReferences_InMainProjectWorks - Static", null, true);

                test.ItemGroup = CreateSingleNativeRef("/Library/Frameworks/iTunesLibrary.framework", "Framework");
                NativeReferenceTestCore(tmpDir, test, "Unified_WithNativeReferences_InMainProjectWorks - Framework", null, true);
                Assert.True(Directory.Exists(Path.Combine(tmpDir, "bin/Debug/UnifiedExample.app/Contents/Frameworks/iTunesLibrary.framework")));

                string binaryPath = Path.Combine(tmpDir, "bin/Debug/UnifiedExample.app/Contents/MacOS/UnifiedExample");
                string otoolText  = TI.RunAndAssert("/usr/bin/otool", new StringBuilder("-l " + binaryPath), "Unified_WithNativeReferences_InMainProjectWorks - rpath");
                Assert.True(otoolText.Contains("path @loader_path/../Frameworks"));
            });
        }
Beispiel #3
0
        public void DynamicSymbolMode(string mode)
        {
            MMPTests.RunMMPTest(tmpDir => {
                TI.UnifiedTestConfig config = new TI.UnifiedTestConfig(tmpDir)
                {
                    CSProjConfig = $"<MonoBundlingExtraArgs>--dynamic-symbol-mode={mode}</MonoBundlingExtraArgs>\n",
                };
                var output       = TI.TestUnifiedExecutable(config);
                var build_output = output.BuildResult.BuildOutput;
                switch (mode)
                {
                case "linker":
                case "default":
                    Assert.That(build_output, Does.Contain("-u "), "reference.m");
                    Assert.That(build_output, Does.Not.Contain("reference.m"), "reference.m");
                    break;

                case "code":
                    Assert.That(build_output, Does.Not.Contain("-u "), "reference.m");
                    Assert.That(build_output, Does.Contain("reference.m"), "reference.m");
                    break;

                case "ignore":
                    Assert.That(build_output, Does.Not.Contain("-u "), "reference.m");
                    Assert.That(build_output, Does.Not.Contain("reference.m"), "reference.m");
                    break;

                default:
                    throw new NotImplementedException();
                }
            });
        }
        public void AllowsUnresolvableReferences()
        {
            MMPTests.RunMMPTest(tmpDir => {
                string [] sb;

                // build b.dll
                sb = new [] { "-target:library", $"-out:{tmpDir}/b.dll", $"{tmpDir}/b.cs" };
                File.WriteAllText(Path.Combine(tmpDir, "b.cs"), "public class B { }");
                TI.RunAndAssert("/Library/Frameworks/Mono.framework/Commands/csc", sb, "b");

                // build a.dll
                sb = new [] { "-target:library", $"-out:{tmpDir}/a.dll", $"{tmpDir}/a.cs", $"-r:{tmpDir}/b.dll" };
                File.WriteAllText(Path.Combine(tmpDir, "a.cs"), "public class A { public A () { System.Console.WriteLine (typeof (B)); }}");
                TI.RunAndAssert("/Library/Frameworks/Mono.framework/Commands/csc", sb, "a");

                File.Delete(Path.Combine(tmpDir, "b.dll"));

                // build project referencing a.dll
                TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
                {
                    References = string.Format(" <Reference Include=\"a\" > <HintPath>{0}/a.dll</HintPath> </Reference> ", tmpDir),
                    TestCode   = "System.Console.WriteLine (typeof (A));",
                };
                TI.GenerateAndBuildUnifiedExecutable(test);
            });
        }
Beispiel #5
0
 public void MM0138()
 {
     MMPTests.RunMMPTest(tmpDir => {
         var rv = TI.TestClassicExecutable(tmpDir, csprojConfig: "<IncludeMonoRuntime>true</IncludeMonoRuntime>", shouldFail: true);
         rv.Messages.AssertError(138, "Building 32-bit apps is not possible when using Xcode 10. Please migrate project to the Unified API.");
         rv.Messages.AssertWarningCount(0);
     });
 }
        public void ShouldStripMonoPosixHelper(bool?strip, bool debugStrips, bool releaseStrips)
        {
            MMPTests.RunMMPTest(tmpDir =>
            {
                TI.UnifiedTestConfig test = CreateStripTestConfig(strip, tmpDir);

                StripTestCore(test, debugStrips, releaseStrips, "Contents/MonoBundle/libMonoPosixHelper.dylib", shouldWarn: false);
            });
        }
Beispiel #7
0
        public void MultipleDependencyChain(bool useProjectReference)
        {
            // App can depend on Lib that depends on binding lib with native reference and everything gets packaged in correctly
            MMPTests.RunMMPTest(tmpDir => {
                TI.UnifiedTestConfig binding = new TI.UnifiedTestConfig(tmpDir)
                {
                    ProjectName = "MobileBinding.csproj"
                };
                binding.ItemGroup           += NativeReferenceTests.CreateSingleNativeRef(NativeReferenceTests.SimpleDylibPath, "Dynamic");
                binding.APIDefinitionConfig += @"[BaseType (typeof (NSObject))]
  interface SimpleClass {
    [Export (""doIt"")]
    int DoIt ();
  }";
                BindingProjectTests.SetNoEmbedding(binding);

                TI.GenerateBindingLibraryProject(binding);
                TI.BuildProject(Path.Combine(tmpDir, "MobileBinding.csproj"), true);


                TI.UnifiedTestConfig library = new TI.UnifiedTestConfig(tmpDir)
                {
                    ProjectName = "UnifiedLibrary"
                };
                library.TestCode = "public class MyClass { public static void Go () { var c = new ExampleBinding.SimpleClass (); c.DoIt (); } }";

                if (useProjectReference)
                {
                    library.References = $@"<ProjectReference Include=""MobileBinding.csproj"" />";
                }
                else
                {
                    library.References = $@"<Reference Include=""MobileBinding""><HintPath>{Path.Combine (tmpDir, "bin/Debug", "MobileBinding.dll")}</HintPath></Reference>";
                }

                TI.GenerateUnifiedLibraryProject(library);
                TI.BuildProject(Path.Combine(tmpDir, "UnifiedLibrary.csproj"), true);

                TI.UnifiedTestConfig project = new TI.UnifiedTestConfig(tmpDir)
                {
                    ProjectName = "UnifiedExample.csproj"
                };
                project.TestCode = "MyClass.Go ();";

                if (useProjectReference)
                {
                    project.References = $@"<ProjectReference Include=""UnifiedLibrary.csproj"" />";
                }
                else
                {
                    project.References = $@"<Reference Include=""UnifiedLibrary""><HintPath>{Path.Combine (tmpDir, "bin/Debug", "UnifiedLibrary.dll")}</HintPath></Reference>";
                }

                TI.GenerateUnifiedExecutableProject(project);
                TI.BuildProject(Path.Combine(tmpDir, "UnifiedExample.csproj"), true);
            });
        }
Beispiel #8
0
 public void ShouldStripMonoPosixHelper(bool?strip, bool debugStrips, bool releaseStrips)
 {
     MMPTests.RunMMPTest(tmpDir =>
     {
         TI.UnifiedTestConfig test = CreateStripTestConfig(strip, tmpDir);
         // Mono's linker is smart enough to remove libMonoPosixHelper unless used (DeflateStream uses it)
         test.TestCode = "using (var ms = new System.IO.MemoryStream ()) { using (var gz = new System.IO.Compression.DeflateStream (ms, System.IO.Compression.CompressionMode.Compress)) { }}";
         StripTestCore(test, debugStrips, releaseStrips, "Contents/MonoBundle/libMonoPosixHelper.dylib", shouldWarn: false);
     });
 }
        public void ShouldStripUserFramework(bool?strip, bool debugStrips, bool releaseStrips)
        {
            MMPTests.RunMMPTest(tmpDir =>
            {
                var frameworkPath         = FrameworkBuilder.CreateFatFramework(tmpDir);
                TI.UnifiedTestConfig test = CreateStripTestConfig(strip, tmpDir, $"--native-reference={frameworkPath}");

                StripTestCore(test, debugStrips, releaseStrips, "Contents/Frameworks/Foo.framework/Foo", shouldWarn: true);
            });
        }
Beispiel #10
0
 public void Unified_SmokeTest(bool full)
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             XM45 = full
         };
         TI.TestUnifiedExecutable(test);
     });
 }
Beispiel #11
0
 public void Modern_SmokeTest_LinkAll()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = "<LinkMode>Full</LinkMode>"
         };
         TI.TestUnifiedExecutable(test);
     });
 }
Beispiel #12
0
 public void ShouldNotMutateModernWithOptInFlag()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = MigrateCSProjTag
         };
         var buildOutput = TI.TestUnifiedExecutable(test).BuildResult;
         Assert.True(MatchesTFI("Xamarin.Mac", buildOutput), $"Build did not have expected TFI.");
     });
 }
        public void Classic_SmokeTest()
        {
            if (ShouldSkipClassicTest)
            {
                return;
            }

            MMPTests.RunMMPTest(tmpDir => {
                TI.TestClassicExecutable(tmpDir);
            });
        }
Beispiel #14
0
 public void LinkingAdditionalArguments_ShouldBeUsed()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = "<MonoBundlingExtraArgs>-v -v --linkplatform</MonoBundlingExtraArgs>"
         };
         var testResult = TI.TestUnifiedExecutable(test);
         Assert.IsTrue(testResult.BuildResult.BuildOutput.Contains("Selected Linking: 'Platform'"), $"Build Output did not contain expected selected linking line: {testResult}");
     });
 }
Beispiel #15
0
 public void LinkingWithPartialStatic_ShouldFail()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = "<MonoBundlingExtraArgs>--registrar:partial --linkplatform</MonoBundlingExtraArgs>"
         };
         var testResult = TI.TestUnifiedExecutable(test, shouldFail: true);
         testResult.BuildResult.Messages.AssertError(2110, "Xamarin.Mac 'Partial Static' registrar does not support linking. Disable linking or use another registrar mode.");
     });
 }
Beispiel #16
0
 public void MM0143()
 {
     MMPTests.RunMMPTest(tmpDir => {
         string csprojTarget = Path.Combine(TI.FindSourceDirectory(), "ClassicExample.csproj");
         string buildOutput  = TI.BuildClassicProject(csprojTarget);
         Console.WriteLine(buildOutput);
         var rv = new OutputText(buildOutput, string.Empty);
         rv.Messages.AssertError(143, "Projects using the Classic API are not supported anymore. Please migrate the project to the Unified API.");
         rv.Messages.AssertWarningCount(0);
     });
 }
Beispiel #17
0
 public void AOT_SmokeTest(bool useProjectTags)
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = GetTestConfig(TestType.Base, useProjectTags)
         };
         TI.TestUnifiedExecutable(test);
         ValidateAOTStatus(tmpDir, f => ShouldBaseFilesBeAOT(f));
     });
 }
Beispiel #18
0
 public void LinkingWithPartialStatic_ShouldFail()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = "<MonoBundlingExtraArgs>--registrar:partial --linkplatform</MonoBundlingExtraArgs>"
         };
         string buildOutput = TI.TestUnifiedExecutable(test, shouldFail: true).BuildOutput;
         Assert.True(buildOutput.Contains("2110"), $"Building did not give the expected 2110 error.\n\n{buildOutput}");
     });
 }
 public void ShouldAllowReference_ToOpenTK(bool full)
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             References = " <Reference Include=\"OpenTK\" />",
             TestCode   = "var matrix = new OpenTK.Matrix2 ();",
             XM45       = full
         };
         TI.TestUnifiedExecutable(test);
     });
 }
        public void ShouldBuildWithoutErrors_AndLinkCorrectFramework(BindingProjectType type, bool noEmbedding = false)
        {
            MMPTests.RunMMPTest(tmpDir => {
                var projects = GenerateTestProject(type, tmpDir);
                if (noEmbedding)
                {
                    SetNoEmbedding(projects.Item1);
                }

                var logs = SetupAndBuildLinkedTestProjects(projects.Item1, projects.Item2, tmpDir, useProjectReference: false, setupDefaultNativeReference: noEmbedding);

                Assert.True(logs.Item1.Contains("csc"), "Bindings project must use csc:\n" + logs.Item1);

                var bgenInvocation = logs.Item1.SplitLines().First(x => x.Contains("bin/bgen"));
                var bgenParts      = bgenInvocation.Split(new char[] { ' ' });
                var mscorlib       = bgenParts.First(x => x.Contains("mscorlib.dll"));
                var system         = bgenParts.First(x => x.Contains("System.dll"));

                switch (type)
                {
                case BindingProjectType.Modern:
                case BindingProjectType.ModernNoTag:
                    Assert.True(mscorlib.EndsWith("lib/mono/Xamarin.Mac/mscorlib.dll", StringComparison.Ordinal), "mscorlib not found in expected Modern location: " + mscorlib);
                    Assert.True(system.EndsWith("lib/mono/Xamarin.Mac/System.dll", StringComparison.Ordinal), "system not found in expected Modern location: " + system);
                    break;

                case BindingProjectType.Full:
                case BindingProjectType.FullTVF:
                case BindingProjectType.FullXamMacTag:
                    Assert.True(mscorlib.EndsWith("lib/mono/4.5/mscorlib.dll", StringComparison.Ordinal), "mscorlib not found in expected Full location: " + mscorlib);
                    Assert.True(system.EndsWith("lib/mono/4.5/System.dll", StringComparison.Ordinal), "system not found in expected Full location: " + system);
                    break;

                default:
                    throw new NotImplementedException();
                }

                Assert.False(logs.Item1.Contains("CS1685"), "Binding should not contains CS1685 multiple definition warning:\n" + logs.Item1);

                Assert.False(logs.Item1.Contains("MSB9004"), "Binding should not contains MSB9004 warning:\n" + logs.Item1);

                string bindingName = RemoveCSProj(projects.Item1.ProjectName);
                string appName     = RemoveCSProj(projects.Item2.ProjectName);
                string libPath     = Path.Combine(tmpDir, $"bin/Debug/{appName}.app/Contents/MonoBundle/{bindingName}.dll");

                Assert.True(File.Exists(libPath));
                string results      = TI.RunAndAssert("/Library/Frameworks/Mono.framework/Commands/monop", new [] { "--refs", "-r:" + libPath }, "monop");
                string mscorlibLine = results.Split(new char[] { '\n' }).First(x => x.Contains("mscorlib"));

                string expectedVersion = GetExpectedBCLVersion(type);
                Assert.True(mscorlibLine.Contains(expectedVersion), $"{mscorlibLine} did not contain expected version {expectedVersion}");
            });
        }
Beispiel #21
0
        public void UnifiedWithoutLinking_ShouldHaveManyFrameworkClangLines()
        {
            MMPTests.RunMMPTest(tmpDir => {
                // By default we -framework in all frameworks we bind.
                string [] clangParts = MMPTests.GetUnifiedProjectClangInvocation(tmpDir);
                AssertUnlinkedFrameworkStatus(clangParts);

                // Even with static registrar
                clangParts = MMPTests.GetUnifiedProjectClangInvocation(tmpDir, StaticRegistrarConfig);
                AssertUnlinkedFrameworkStatus(clangParts);
            });
        }
        public void Unified_WithNativeReferences_IgnoredWorks()
        {
            MMPTests.RunMMPTest(tmpDir => {
                TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
                {
                    ItemGroup    = CreateSingleNativeRef(Path.GetFullPath(SimpleDylibPath), "Dynamic"),
                    CSProjConfig = string.Format(@"<MonoBundlingExtraArgs>--ignore-native-library=""{0}""</MonoBundlingExtraArgs>", Path.GetFullPath(SimpleDylibPath))
                };

                NativeReferenceTestCore(tmpDir, test, "Unified_WithNativeReferences_InMainProjectWorks - Local", null, true, true);
            });
        }
 public void ShouldNotAllowReference_ToSystemDrawing()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             References = " <Reference Include=\"System.Drawing\" />",
             TestCode   = "System.Drawing.RectangleF f = new System.Drawing.RectangleF ();",
             XM45       = true
         };
         TI.TestUnifiedExecutable(test, shouldFail: true);
     });
 }
Beispiel #24
0
        public void AOT_32Bit_SmokeTest()
        {
            MMPTests.RunMMPTest(tmpDir => {
                TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
                {
                    CSProjConfig = "<XamMacArch>i386</XamMacArch>" + AOTTestBaseConfig
                };
                string buildResults = TI.TestUnifiedExecutable(test).BuildOutput;

                ValidateAOTStatus(tmpDir, f => ShouldBaseFilesBeAOT(f), buildResults);
            });
        }
 public void LongProfileStrings_ErrorsWhenWrongXMPassedToRightProfile()
 {
     MMPTests.RunMMPTest(tmpDir => {
         foreach (var targetProfile in XMTargetFrameworks)
         {
             string libPath      = CreateTestExe(tmpDir);
             string args         = GetTestMMPInvocation(tmpDir, libPath, targetProfile, false);
             string buildResults = TI.RunAndAssert(MMPPath, args, "mmp invoke with wrong XM", shouldFail: true);
             Assert.IsTrue(buildResults.Contains("1407"), "Did not contains 1407 error expected");
         }
     });
 }
		public void DirectoryContainsSpaces (bool full, string arch)
		{
			if (!PlatformHelpers.CheckSystemVersion (10, 11))
				return;

			MMPTests.RunMMPTest (tmpDir => {
				TI.UnifiedTestConfig test = new TI.UnifiedTestConfig (tmpDir) {
					CSProjConfig = $"<MonoBundlingExtraArgs>--registrar=static</MonoBundlingExtraArgs><XamMacArch>{arch}</XamMacArch>",
					XM45 = full
				};
			}, "test withSpace");
		}
Beispiel #27
0
        public void DoesNotSupportLinkWith(BindingProjectType type)
        {
            MMPTests.RunMMPTest(tmpDir => {
                var projects = BindingProjectTests.GenerateTestProject(type, tmpDir);
                BindingProjectTests.SetNoEmbedding(projects.Item1);

                projects.Item1.LinkWithName = "SimpleClassDylib.dylib";

                string libBuildLog = BindingProjectTests.SetupAndBuildBindingProject(projects.Item1, false, shouldFail: true);
                Assert.True(libBuildLog.Contains("Can't create a binding resource package unless there are native references in the binding project."), $"Did not fail as expected: {TI.PrintRedirectIfLong (libBuildLog)}");
            });
        }
Beispiel #28
0
        public void LibrariesEmbeddedProperly(BindingProjectType type, bool useProjectReference)
        {
            MMPTests.RunMMPTest(tmpDir => {
                var projects = BindingProjectTests.GenerateTestProject(type, tmpDir);
                BindingProjectTests.SetNoEmbedding(projects.Item1);

                string appBuildLog = BindingProjectTests.SetupAndBuildLinkedTestProjects(projects.Item1, projects.Item2, tmpDir, useProjectReference, setupDefaultNativeReference: true).Item2;

                AssertNoResourceWithName(tmpDir, projects.Item1.ProjectName, "SimpleClassDylib.dylib");
                AssertFileInBundle(tmpDir, type, "MonoBundle/SimpleClassDylib.dylib");
            });
        }
Beispiel #29
0
        public void CleanShouldRemoveBundle()
        {
            MMPTests.RunMMPTest(tmpDir => {
                var projects = BindingProjectTests.GenerateTestProject(BindingProjectType.Modern, tmpDir);
                BindingProjectTests.SetNoEmbedding(projects.Item1);

                string libBuildLog = BindingProjectTests.SetupAndBuildBindingProject(projects.Item1, true);

                TI.CleanUnifiedProject(Path.Combine(tmpDir, projects.Item1.ProjectName));
                Assert.False(Directory.Exists(Path.Combine(tmpDir, "bin/Debug/MobileBinding.resources")), "Resource bundle was not cleaned up");
            });
        }
 public void Unified_WithStaticNativeRef_32bit()
 {
     MMPTests.RunMMPTest(tmpDir => {
         TI.UnifiedTestConfig test = new TI.UnifiedTestConfig(tmpDir)
         {
             CSProjConfig = "<XamMacArch>i386</XamMacArch>",
             References   = $"<Reference Include=\"SimpleBinding_static\"><HintPath>{MobileStaticBindingPath}</HintPath></Reference>",
             TestCode     = "System.Console.WriteLine (new Simple.SimpleClass ().DoIt ());"
         };
         NativeReferenceTestCore(tmpDir, test, "Unified_WithStaticNativeRef_32bit", null, true, false);
     });
 }