public void BuildFatMonoTouchTest(ApplePlatform platform, string runtimeIdentifiers, params string[] additionalProperties)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = Path.Combine(Configuration.SourceRoot, "tests", "monotouch-test", "dotnet", platform.AsString(), "monotouch-test.csproj");
Configuration.CopyDotNetSupportingFiles(Path.GetDirectoryName(Path.GetDirectoryName(project_path)));
Configuration.CopyDotNetSupportingFiles(Path.Combine(Configuration.SourceRoot, "tests", "bindings-test", "dotnet"));
Configuration.CopyDotNetSupportingFiles(Path.Combine(Configuration.SourceRoot, "tests", "bindings-test2", "dotnet"));
Configuration.CopyDotNetSupportingFiles(Path.Combine(Configuration.SourceRoot, "tests", "EmbeddedResources", "dotnet"));
Configuration.CopyDotNetSupportingFiles(Path.Combine(Configuration.SourceRoot, "tests", "fsharplibrary", "dotnet"));
Configuration.CopyDotNetSupportingFiles(Path.Combine(Configuration.SourceRoot, "external", "Touch.Unit", "Touch.Client", "dotnet"));
Clean(project_path);
var properties = GetDefaultProperties(runtimeIdentifiers);
if (additionalProperties != null)
{
foreach (var prop in additionalProperties)
{
var eq = prop.IndexOf('=');
var name = prop.Substring(0, eq);
var value = prop.Substring(eq + 1);
properties [name] = value;
}
}
var result = DotNet.AssertBuild(project_path, properties);
var appPath = Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", platform.ToFramework(), "monotouchtest.app");
var infoPlistPath = GetInfoPListPath(platform, appPath);
Assert.That(infoPlistPath, Does.Exist, "Info.plist");
var infoPlist = PDictionary.FromFile(infoPlistPath);
Assert.AreEqual("com.xamarin.monotouch-test", infoPlist.GetString("CFBundleIdentifier").Value, "CFBundleIdentifier");
Assert.AreEqual("MonoTouchTest", infoPlist.GetString("CFBundleDisplayName").Value, "CFBundleDisplayName");
}
public void BuildEmbeddedResourcesTest(string platform)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var assemblyName = "EmbeddedResources";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.csproj");
Clean(project_path);
Configuration.CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = result.StandardOutput.ToString().Split('\n');
// Find the resulting binding assembly from the build log
var assemblies = FilterToAssembly(lines, assemblyName);
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
assemblies = assemblies.Distinct();
Assert.That(assemblies.Count(), Is.EqualTo(1), $"Unique assemblies\n\t{string.Join ("\n\t", assemblies)}");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's one resource in the assembly, and its name
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count, Is.EqualTo(1), "1 resource");
Assert.That(ad.MainModule.Resources [0].Name, Is.EqualTo("EmbeddedResources.Welcome.resources"), "libtest.a");
var asm_dir = Path.GetDirectoryName(asm);
Assert.That(Path.Combine(asm_dir, "en-AU", "EmbeddedResources.resources.dll"), Does.Exist, "en-AU");
Assert.That(Path.Combine(asm_dir, "de", "EmbeddedResources.resources.dll"), Does.Exist, "de");
Assert.That(Path.Combine(asm_dir, "es", "EmbeddedResources.resources.dll"), Does.Exist, "es");
}
public void NativeReferenceStaticLibraryForceLoad(ApplePlatform platform, bool?simulator)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var tmpdir = Cache.CreateTemporaryDirectory();
var magic = Guid.NewGuid().ToString();
var pathToNativeLibrary = Path.Combine(Configuration.GetTestLibraryDirectory(platform, simulator), "libtest.a");
var relativePathToNativeLibrary = Path.GetRelativePath(tmpdir, pathToNativeLibrary);
var csproj = $@"<Project Sdk=""Microsoft.NET.Sdk"">
<PropertyGroup>
<TargetFramework>{platform.ToFramework ()}</TargetFramework>
<OutputType>Exe</OutputType>
</PropertyGroup>
<ItemGroup>
<NativeReference Include=""{relativePathToNativeLibrary}"">
<Kind>Static</Kind>
<ForceLoad>True</ForceLoad>
</NativeReference>
</ItemGroup>
</Project>";
Configuration.CopyDotNetSupportingFiles(tmpdir);
var project_path = Path.Combine(tmpdir, "TestProject.csproj");
File.WriteAllText(project_path, csproj);
File.WriteAllText(Path.Combine(tmpdir, "Info.plist"), EmptyAppManifest);
File.WriteAllText(Path.Combine(tmpdir, "Main.cs"), EmptyMainFile);
DotNet.AssertBuild(project_path, GetDefaultProperties());
}
public void BuildBindingsTest2(string platform)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var assemblyName = "bindings-test2";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.csproj");
Clean(project_path);
Configuration.CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = BinLog.PrintToLines(result.BinLogPath);
// Find the resulting binding assembly from the build log
var assemblies = FilterToAssembly(lines, assemblyName);
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
Assert.That(assemblies.Distinct().Count(), Is.EqualTo(1), "Unique assemblies");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's one resource in the binding assembly, and its name
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count, Is.EqualTo(1), "1 resource");
Assert.That(ad.MainModule.Resources [0].Name, Is.EqualTo("libtest2.a"), "libtest2.a");
}
public void BuildMySingleView(string runtimeIdentifier)
{
var platform = ApplePlatform.iOS;
var project_path = GetProjectPath("MySingleView");
Configuration.IgnoreIfIgnoredPlatform(platform);
Clean(project_path);
var properties = new Dictionary <string, string> (verbosity);
if (!string.IsNullOrEmpty(runtimeIdentifier))
{
properties ["RuntimeIdentifier"] = runtimeIdentifier;
}
else
{
runtimeIdentifier = "iossimulator-x64"; // default RID for iOS projects. We set it here to make the rest of the test know where to expect files to be.
}
var result = DotNet.AssertBuild(project_path, properties);
AssertThatLinkerExecuted(result);
var appPath = Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", "net6.0-ios", runtimeIdentifier, "MySingleView.app");
AssertAppContents(platform, appPath);
var infoPlistPath = Path.Combine(appPath, "Info.plist");
var infoPlist = PDictionary.FromFile(infoPlistPath);
Assert.AreEqual("com.xamarin.mysingletitle", infoPlist.GetString("CFBundleIdentifier").Value, "CFBundleIdentifier");
Assert.AreEqual("MySingleTitle", infoPlist.GetString("CFBundleDisplayName").Value, "CFBundleDisplayName");
Assert.AreEqual("3.14", infoPlist.GetString("CFBundleVersion").Value, "CFBundleVersion");
Assert.AreEqual("3.14", infoPlist.GetString("CFBundleShortVersionString").Value, "CFBundleShortVersionString");
}
public void BuildFatApp(ApplePlatform platform, string runtimeIdentifiers)
{
var project = "MySimpleApp";
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = GetProjectPath(project, platform: platform);
Clean(project_path);
var properties = new Dictionary <string, string> (verbosity);
properties ["RuntimeIdentifiers"] = runtimeIdentifiers;
var result = DotNet.AssertBuild(project_path, properties);
AssertThatLinkerExecuted(result);
var appPath = Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", platform.ToFramework(), $"{project}.app");
var infoPlistPath = GetInfoPListPath(platform, appPath);
Assert.That(infoPlistPath, Does.Exist, "Info.plist");
var infoPlist = PDictionary.FromFile(infoPlistPath);
Assert.AreEqual("com.xamarin.mysimpleapp", infoPlist.GetString("CFBundleIdentifier").Value, "CFBundleIdentifier");
Assert.AreEqual("MySimpleApp", infoPlist.GetString("CFBundleDisplayName").Value, "CFBundleDisplayName");
Assert.AreEqual("3.14", infoPlist.GetString("CFBundleVersion").Value, "CFBundleVersion");
Assert.AreEqual("3.14", infoPlist.GetString("CFBundleShortVersionString").Value, "CFBundleShortVersionString");
}
public void IsNotMacBuild(string runtimeIdentifier, bool isDeviceBuild)
{
if (isDeviceBuild)
{
Configuration.AssertDeviceAvailable();
}
var platform = ApplePlatform.iOS;
var project_path = GetProjectPath("MySingleView");
Configuration.IgnoreIfIgnoredPlatform(platform);
Clean(project_path);
var properties = new Dictionary <string, string> (verbosity);
properties ["RuntimeIdentifier"] = runtimeIdentifier;
properties ["IsMacEnabled"] = "false";
var result = DotNet.AssertBuild(project_path, properties);
AssertThatLinkerDidNotExecute(result);
var appPath = Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", "net6.0-ios", runtimeIdentifier, "MySingleView.app");
var appExecutable = Path.Combine(appPath, Path.GetFileName(project_path));
Assert.That(appPath, Does.Exist, "There is an .app");
Assert.That(appExecutable, Does.Not.Empty, "There is no executable");
Assert.That(Path.Combine(appPath, "Xamarin.iOS.dll"), Does.Exist, "Xamarin.iOS.dll is in the bundle");
}
public void BuildFSharpLibraryTest(string platform)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var assemblyName = "fsharplibrary";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.fsproj");
Clean(project_path);
Configuration.CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = BinLog.PrintToLines(result.BinLogPath);
// Find the resulting binding assembly from the build log
var assemblies = FilterToAssembly(lines, assemblyName);
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
Assert.That(assemblies.Distinct().Count(), Is.EqualTo(1), "Unique assemblies");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's no resources in the assembly
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count(), Is.EqualTo(2), "2 resources"); // There are 2 embedded resources by default by the F# compiler.
}
public void BuildBundledResources(string platform, string prefix)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var assemblyName = "BundledResources";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.csproj");
Clean(project_path);
Configuration.CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = BinLog.PrintToLines(result.BinLogPath);
// Find the resulting binding assembly from the build log
var assemblies = FilterToAssembly(lines, assemblyName);
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
Assert.That(assemblies.Distinct().Count(), Is.EqualTo(1), "Unique assemblies");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's one resource in the binding assembly, and its name
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count, Is.EqualTo(2), "2 resources");
// Sort the resources before we assert, since we don't care about the order, and sorted order makes the asserts simpler.
var resources = ad.MainModule.Resources.OrderBy(v => v.Name).ToArray();
Assert.That(resources [0].Name, Is.EqualTo($"__{prefix}_content_basn3p08.png"), $"__{prefix}_content_basn3p08.png");
Assert.That(resources [1].Name, Is.EqualTo($"__{prefix}_content_xamvideotest.mp4"), $"__{prefix}_content_xamvideotest.mp4");
}
public void BuildCoreCLR(ApplePlatform platform, string runtimeIdentifiers)
{
var project = "MySimpleApp";
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = GetProjectPath(project, runtimeIdentifiers: runtimeIdentifiers, platform: platform, out var appPath);
Clean(project_path);
var properties = GetDefaultProperties(runtimeIdentifiers);
properties ["UseMonoRuntime"] = "false";
var rv = DotNet.AssertBuild(project_path, properties);
AssertThatLinkerExecuted(rv);
var infoPlistPath = GetInfoPListPath(platform, appPath);
Assert.That(infoPlistPath, Does.Exist, "Info.plist");
var infoPlist = PDictionary.FromFile(infoPlistPath);
Assert.AreEqual("com.xamarin.mysimpleapp", infoPlist.GetString("CFBundleIdentifier").Value, "CFBundleIdentifier");
Assert.AreEqual("MySimpleApp", infoPlist.GetString("CFBundleDisplayName").Value, "CFBundleDisplayName");
Assert.AreEqual("3.14", infoPlist.GetString("CFBundleVersion").Value, "CFBundleVersion");
Assert.AreEqual("3.14", infoPlist.GetString("CFBundleShortVersionString").Value, "CFBundleShortVersionString");
var appExecutable = GetNativeExecutable(platform, appPath);
ExecuteWithMagicWordAndAssert(platform, runtimeIdentifiers, appExecutable);
var createdump = Path.Combine(appPath, "Contents", "MonoBundle", "createdump");
Assert.That(createdump, Does.Exist, "createdump existence");
}
public void BindingWithDefaultCompileInclude(ApplePlatform platform)
{
var project = "BindingWithDefaultCompileInclude";
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = GetProjectPath(project, platform: platform);
Clean(project_path);
var rv = DotNet.AssertBuild(project_path, GetDefaultProperties());
var dllPath = Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", platform.ToFramework(), $"{project}.dll");
Assert.That(dllPath, Does.Exist, "Binding assembly");
// Verify that the MyNativeClass class exists in the assembly, and that it's actually a class.
var ad = AssemblyDefinition.ReadAssembly(dllPath, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
var myNativeClass = ad.MainModule.Types.FirstOrDefault(v => v.FullName == "MyApiDefinition.MyNativeClass");
Assert.IsFalse(myNativeClass.IsInterface, "IsInterface");
var myStruct = ad.MainModule.Types.FirstOrDefault(v => v.FullName == "MyClassLibrary.MyStruct");
Assert.IsTrue(myStruct.IsValueType, "MyStruct");
var warnings = BinLog.GetBuildLogWarnings(rv.BinLogPath).Select(v => v.Message);
Assert.That(warnings, Is.Empty, $"Build warnings:\n\t{string.Join ("\n\t", warnings)}");
}
public void BuildBindingsTest2(string platform)
{
if (!Configuration.include_mac)
{
Assert.Ignore("Ignore until Xamarin.Mac is re-enabled. Issue: https://github.com/xamarin/xamarin-macios/issues/9680");
}
var assemblyName = "bindings-test2";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.csproj");
Clean(project_path);
Configuration.CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = result.StandardOutput.ToString().Split('\n');
// Find the resulting binding assembly from the build log
var assemblies = FilterToAssembly(lines, assemblyName);
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
Assert.That(assemblies.Distinct().Count(), Is.EqualTo(1), "Unique assemblies");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's one resource in the binding assembly, and its name
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count, Is.EqualTo(1), "1 resource");
Assert.That(ad.MainModule.Resources [0].Name, Is.EqualTo("libtest2.a"), "libtest2.a");
}
public void BuildMyClassLibrary (string platform)
{
Configuration.IgnoreIfIgnoredPlatform (platform);
var project_path = GetProjectPath ("MyClassLibrary", platform);
Clean (project_path);
var result = DotNet.AssertBuild (project_path, verbosity);
Assert.That (result.StandardOutput.ToString (), Does.Not.Contain ("Task \"ILLink\""), "Linker executed unexpectedly.");
}
public void BuildMyTVApp()
{
var project_path = GetProjectPath("MyTVApp");
Clean(project_path);
var result = DotNet.AssertBuild(project_path);
AssertThatLinkerExecuted(result);
}
// [TestCase ("watchOS")] // No watchOS Touch.Client project for .NET yet
// [TestCase ("macOS")] // No macOS Touch.Client project for .NET yet
public void BuildInterdependentBindingProjects (string platform)
{
Configuration.IgnoreIfIgnoredPlatform (platform);
var assemblyName = "interdependent-binding-projects";
var dotnet_bindings_dir = Path.Combine (Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine (dotnet_bindings_dir, platform);
var project_path = Path.Combine (project_dir, $"{assemblyName}.csproj");
Clean (project_path);
Configuration.CopyDotNetSupportingFiles (dotnet_bindings_dir);
Configuration.CopyDotNetSupportingFiles (dotnet_bindings_dir.Replace (assemblyName, "bindings-test"));
Configuration.CopyDotNetSupportingFiles (dotnet_bindings_dir.Replace (assemblyName, "bindings-test2"));
var cleanupSupportFiles = Configuration.CopyDotNetSupportingFiles (Path.Combine (Configuration.SourceRoot, "external", "Touch.Unit", "Touch.Client/dotnet"));
try {
var result = DotNet.AssertBuild (project_path, verbosity);
var lines = BinLog.PrintToLines (result.BinLogPath);
// Find the resulting binding assembly from the build log
var assemblies = lines.
Select (v => v.Trim ()).
Where (v => {
if (v.Length < 10)
return false;
if (v [0] != '/')
return false;
if (!v.EndsWith ($"{assemblyName}.dll", StringComparison.Ordinal))
return false;
if (!v.Contains ("/bin/", StringComparison.Ordinal))
return false;
if (!v.Contains ($"{assemblyName}.app", StringComparison.Ordinal))
return false;
return true;
});
Assert.That (assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
assemblies = assemblies.Distinct ();
Assert.That (assemblies.Count (), Is.EqualTo (1), $"Unique assemblies: {string.Join (", ", assemblies)}");
var asm = assemblies.First ();
Assert.That (asm, Does.Exist, "Assembly existence");
// Verify that the resources have been linked away
var asmDir = Path.GetDirectoryName (asm);
var ad = AssemblyDefinition.ReadAssembly (asm, new ReaderParameters { ReadingMode = ReadingMode.Deferred });
Assert.That (ad.MainModule.Resources.Count, Is.EqualTo (0), "0 resources for interdependent-binding-projects.dll");
var ad1 = AssemblyDefinition.ReadAssembly (Path.Combine (asmDir, "bindings-test.dll"), new ReaderParameters { ReadingMode = ReadingMode.Deferred });
// The native library is removed from the resources by the linker
Assert.That (ad1.MainModule.Resources.Count, Is.EqualTo (0), "0 resources for bindings-test.dll");
var ad2 = AssemblyDefinition.ReadAssembly (Path.Combine (asmDir, "bindings-test2.dll"), new ReaderParameters { ReadingMode = ReadingMode.Deferred });
// The native library is removed from the resources by the linker
Assert.That (ad2.MainModule.Resources.Count, Is.EqualTo (0), "0 resources for bindings-test2.dll");
} finally {
foreach (var file in cleanupSupportFiles)
File.Delete (file);
}
}
public void BuildMyTVApp ()
{
var platform = ApplePlatform.TVOS;
var project_path = GetProjectPath ("MyTVApp");
Configuration.IgnoreIfIgnoredPlatform (platform);
Clean (project_path);
var result = DotNet.AssertBuild (project_path, verbosity);
AssertThatLinkerExecuted (result);
AssertAppContents (platform, Path.Combine (Path.GetDirectoryName (project_path), "bin", "Debug", "net6.0-tvos", "tvos-x64", "MyTVApp.app"));
}
public void BuildMyCocoaApp()
{
var platform = ApplePlatform.MacOSX;
var project_path = GetProjectPath("MyCocoaApp");
Clean(project_path);
var result = DotNet.AssertBuild(project_path, verbosity);
AssertThatLinkerExecuted(result);
AssertAppContents(platform, Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", "net5.0", "osx-x64", "MyCocoaApp.app"));
}
public void BuildMySingleView()
{
var platform = ApplePlatform.iOS;
var project_path = GetProjectPath("MySingleView");
Clean(project_path);
var result = DotNet.AssertBuild(project_path, verbosity);
AssertThatLinkerExecuted(result);
AssertAppContents(platform, Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", "net5.0-ios", "ios-x64", "MySingleView.app"));
}
public void BuildEmbeddedResourcesTest(string platform)
{
var assemblyName = "EmbeddedResources";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.csproj");
Clean(project_path);
CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = result.StandardOutput.ToString().Split('\n');
// Find the resulting binding assembly from the build log
var assemblies = lines.
Select(v => v.Trim()).
Where(v => {
if (v.Length < 10)
{
return(false);
}
if (v [0] != '/')
{
return(false);
}
if (!v.EndsWith($"{assemblyName}.dll", StringComparison.Ordinal))
{
return(false);
}
if (!v.Contains("/bin/", StringComparison.Ordinal))
{
return(false);
}
return(true);
});
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
Assert.That(assemblies.Distinct().Count(), Is.EqualTo(1), "Unique assemblies");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's one resource in the assembly, and its name
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count, Is.EqualTo(1), "1 resource");
Assert.That(ad.MainModule.Resources [0].Name, Is.EqualTo("EmbeddedResources.Welcome.resources"), "libtest.a");
var asm_dir = Path.GetDirectoryName(asm);
Assert.That(Path.Combine(asm_dir, "en-AU", "EmbeddedResources.resources.dll"), Does.Exist, "en-AU");
Assert.That(Path.Combine(asm_dir, "de", "EmbeddedResources.resources.dll"), Does.Exist, "de");
Assert.That(Path.Combine(asm_dir, "es", "EmbeddedResources.resources.dll"), Does.Exist, "es");
}
public void BuildMyClassLibrary(string platform)
{
if (platform == "macOS" && !Configuration.include_mac)
{
Assert.Ignore("Ignore until Xamarin.Mac is re-enabled. Issue: https://github.com/xamarin/xamarin-macios/issues/9680");
}
var project_path = GetProjectPath("MyClassLibrary", platform);
Clean(project_path);
var result = DotNet.AssertBuild(project_path, verbosity);
Assert.That(result.StandardOutput.ToString(), Does.Not.Contain("Task \"ILLink\""), "Linker executed unexpectedly.");
}
public void BuildMyTVApp(string runtimeIdentifier)
{
var platform = ApplePlatform.TVOS;
var project_path = GetProjectPath("MyTVApp", runtimeIdentifiers: runtimeIdentifier, platform: platform, out var appPath);
Configuration.IgnoreIfIgnoredPlatform(platform);
Clean(project_path);
var properties = GetDefaultProperties(runtimeIdentifier);
var result = DotNet.AssertBuild(project_path, properties);
AssertThatLinkerExecuted(result);
AssertAppContents(platform, appPath);
}
public void DoubleBuild(ApplePlatform platform, string runtimeIdentifiers)
{
var project = "AppWithResources";
Configuration.IgnoreIfIgnoredPlatform(platform);
var projectPath = GetProjectPath(project, runtimeIdentifiers: runtimeIdentifiers, platform: platform, out _);
Clean(projectPath);
DotNet.AssertBuild(projectPath, GetDefaultProperties(runtimeIdentifiers));
DotNet.AssertBuild(projectPath, GetDefaultProperties(runtimeIdentifiers));
}
public void CreateAndBuildTemplate(TemplateInfo info)
{
if (!info.ValidateSuccessfulBuild)
{
return;
}
Configuration.IgnoreIfIgnoredPlatform(info.Platform);
var tmpDir = Cache.CreateTemporaryDirectory();
Configuration.CopyDotNetSupportingFiles(tmpDir);
var outputDir = Path.Combine(tmpDir, info.Template);
DotNet.AssertNew(outputDir, info.Template);
var csproj = Path.Combine(outputDir, info.Template + ".csproj");
var rv = DotNet.AssertBuild(csproj);
var warnings = BinLog.GetBuildLogWarnings(rv.BinLogPath).Select(v => v.Message);
Assert.That(warnings, Is.Empty, $"Build warnings:\n\t{string.Join ("\n\t", warnings)}");
if (info.Execute)
{
var platform = info.Platform;
var runtimeIdentifiers = GetDefaultRuntimeIdentifier(platform);
Assert.IsTrue(CanExecute(info.Platform, runtimeIdentifiers), "Must be executable to execute!");
// First add some code to exit the template if it launches successfully.
var mainFile = Path.Combine(outputDir, "Main.cs");
var mainContents = File.ReadAllText(mainFile);
var exitSampleWithSuccess = @"NSTimer.CreateScheduledTimer (1, (v) => {
Console.WriteLine (Environment.GetEnvironmentVariable (""MAGIC_WORD""));
Environment.Exit (0);
});
" ;
var modifiedMainContents = mainContents.Replace("// This is the main entry point of the application.", exitSampleWithSuccess);
Assert.AreNotEqual(modifiedMainContents, mainContents, "Failed to modify the main content");
File.WriteAllText(mainFile, modifiedMainContents);
// Build the sample
rv = DotNet.AssertBuild(csproj);
// There should still not be any warnings
warnings = BinLog.GetBuildLogWarnings(rv.BinLogPath).Select(v => v.Message);
Assert.That(warnings, Is.Empty, $"Build warnings (2):\n\t{string.Join ("\n\t", warnings)}");
var appPath = GetAppPath(csproj, platform, runtimeIdentifiers);
var appExecutable = GetNativeExecutable(platform, appPath);
ExecuteWithMagicWordAndAssert(appExecutable);
}
}
public void BuildMyCocoaApp()
{
if (!Configuration.include_mac)
{
Assert.Ignore("Ignore until Xamarin.Mac is re-enabled. Issue: https://github.com/xamarin/xamarin-macios/issues/9680");
}
var platform = ApplePlatform.MacOSX;
var project_path = GetProjectPath("MyCocoaApp");
Clean(project_path);
var result = DotNet.AssertBuild(project_path, verbosity);
AssertThatLinkerExecuted(result);
AssertAppContents(platform, Path.Combine(Path.GetDirectoryName(project_path), "bin", "Debug", "net5.0-macos", "osx-x64", "MyCocoaApp.app"));
}
public void CreateAndBuildTemplate(string platform, string template)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var tmpDir = Cache.CreateTemporaryDirectory();
Configuration.CopyDotNetSupportingFiles(tmpDir);
var outputDir = Path.Combine(tmpDir, template);
DotNet.AssertNew(outputDir, template);
var csproj = Path.Combine(outputDir, template + ".csproj");
var rv = DotNet.AssertBuild(csproj);
var warnings = BinLog.GetBuildLogWarnings(rv.BinLogPath).Select(v => v.Message);
Assert.That(warnings, Is.Empty, $"Build warnings:\n\t{string.Join ("\n\t", warnings)}");
}
public void NativeLink(ApplePlatform platform, string runtimeIdentifiers)
{
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = GenerateProject(platform, name: nameof(NativeLink), runtimeIdentifiers: runtimeIdentifiers, out var appPath);
var properties = new Dictionary <string, string> (verbosity);
SetRuntimeIdentifiers(properties, runtimeIdentifiers);
var mainContents = @"
class MainClass {
static int Main ()
{
return 123;
}
}
";
var mainFile = Path.Combine(Path.GetDirectoryName(project_path), "Main.cs");
File.WriteAllText(mainFile, mainContents);
// Build the first time
var rv = DotNet.AssertBuild(project_path, properties);
var allTargets = BinLog.GetAllTargets(rv.BinLogPath);
AssertTargetExecuted(allTargets, "_AOTCompile", "A");
AssertTargetExecuted(allTargets, "_CompileNativeExecutable", "A");
AssertTargetExecuted(allTargets, "_LinkNativeExecutable", "A");
// Capture the current time
var timestamp = DateTime.UtcNow;
File.WriteAllText(mainFile, mainContents + "\n");
// Build again
rv = DotNet.AssertBuild(project_path, properties);
// Check that some targets executed
allTargets = BinLog.GetAllTargets(rv.BinLogPath);
AssertTargetExecuted(allTargets, "_AOTCompile", "B");
AssertTargetNotExecuted(allTargets, "_CompileNativeExecutable", "B");
AssertTargetExecuted(allTargets, "_LinkNativeExecutable", "B");
// Verify that the timestamp of the executable has been updated
var executable = GetNativeExecutable(platform, appPath);
Assert.That(File.GetLastWriteTimeUtc(executable), Is.GreaterThan(timestamp), "B: Executable modified");
}
public void AppWithGenericLibraryReference(ApplePlatform platform, string runtimeIdentifiers)
{
var project = "AppWithGenericLibraryReference";
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = GetProjectPath(project, runtimeIdentifiers: runtimeIdentifiers, platform: platform, out var appPath);
Clean(project_path);
DotNet.AssertBuild(project_path, GetDefaultProperties(runtimeIdentifiers));
var appExecutable = GetNativeExecutable(platform, appPath);
ExecuteWithMagicWordAndAssert(platform, runtimeIdentifiers, appExecutable);
}
public void BuildFSharpLibraryTest(string platform)
{
var assemblyName = "fsharplibrary";
var dotnet_bindings_dir = Path.Combine(Configuration.SourceRoot, "tests", assemblyName, "dotnet");
var project_dir = Path.Combine(dotnet_bindings_dir, platform);
var project_path = Path.Combine(project_dir, $"{assemblyName}.fsproj");
Clean(project_path);
CopyDotNetSupportingFiles(dotnet_bindings_dir);
var result = DotNet.AssertBuild(project_path, verbosity);
var lines = result.StandardOutput.ToString().Split('\n');
// Find the resulting binding assembly from the build log
var assemblies = lines.
Select(v => v.Trim()).
Where(v => {
if (v.Length < 10)
{
return(false);
}
if (v [0] != '/')
{
return(false);
}
if (!v.EndsWith($"{assemblyName}.dll", StringComparison.Ordinal))
{
return(false);
}
if (!v.Contains("/bin/", StringComparison.Ordinal))
{
return(false);
}
return(true);
});
Assert.That(assemblies, Is.Not.Empty, "Assemblies");
// Make sure there's no other assembly confusing our logic
Assert.That(assemblies.Distinct().Count(), Is.EqualTo(1), "Unique assemblies");
var asm = assemblies.First();
Assert.That(asm, Does.Exist, "Assembly existence");
// Verify that there's no resources in the assembly
var ad = AssemblyDefinition.ReadAssembly(asm, new ReaderParameters {
ReadingMode = ReadingMode.Deferred
});
Assert.That(ad.MainModule.Resources.Count(), Is.EqualTo(2), "2 resources"); // There are 2 embedded resources by default by the F# compiler.
}
public void SimpleAppWithOldReferences(ApplePlatform platform, string runtimeIdentifiers)
{
var project = "SimpleAppWithOldReferences";
Configuration.IgnoreIfIgnoredPlatform(platform);
var project_path = GetProjectPath(project, runtimeIdentifiers: runtimeIdentifiers, platform: platform, out var appPath);
Clean(project_path);
DotNet.AssertBuild(project_path, GetDefaultProperties(runtimeIdentifiers));
var appExecutable = GetNativeExecutable(platform, appPath);
Assert.That(appExecutable, Does.Exist, "There is an executable");
ExecuteWithMagicWordAndAssert(platform, runtimeIdentifiers, appExecutable);
}
public void BuildMySingleView ()
{
var platform = ApplePlatform.iOS;
var project_path = GetProjectPath ("MySingleView");
Configuration.IgnoreIfIgnoredPlatform (platform);
Clean (project_path);
var result = DotNet.AssertBuild (project_path, verbosity);
AssertThatLinkerExecuted (result);
var appPath = Path.Combine (Path.GetDirectoryName (project_path), "bin", "Debug", "net6.0-ios", "ios-x64", "MySingleView.app");
AssertAppContents (platform, appPath);
var infoPlistPath = Path.Combine (appPath, "Info.plist");
var infoPlist = PDictionary.FromFile (infoPlistPath);
Assert.AreEqual ("com.xamarin.mysingletitle", infoPlist.GetString ("CFBundleIdentifier").Value, "CFBundleIdentifier");
Assert.AreEqual ("MySingleTitle", infoPlist.GetString ("CFBundleDisplayName").Value, "CFBundleDisplayName");
Assert.AreEqual ("3.14", infoPlist.GetString ("CFBundleVersion").Value, "CFBundleVersion");
Assert.AreEqual ("3.14", infoPlist.GetString ("CFBundleShortVersionString").Value, "CFBundleShortVersionString");
}