public void EnvironmentFileContents()
{
string javaEnv = Path.Combine(testProjectPath, "obj", XABuildPaths.Configuration, "android", "src", "mono", "android", "app", "XamarinAndroidEnvironmentVariables.java");
Assert.That(new FileInfo(javaEnv), Does.Exist, $"File {javaEnv} should exist");
string[] envLines = File.ReadAllLines(javaEnv);
Assert.That(envLines.Any(l => !String.IsNullOrEmpty(l)), Is.True, $"Environment file {javaEnv} must contain at least one non-empty line");
bool found = false;
foreach (string line in envLines)
{
if (String.IsNullOrEmpty(line))
{
continue;
}
if (line.IndexOf("\"__XA_DSO_IN_APK\",") >= 0)
{
found = true;
break;
}
}
Assert.That(found, Is.True, $"The `__XA_DSO_IN_APK` variable wasn't found in the environment file {javaEnv}");
string dexFile = Path.Combine(testProjectPath, "obj", XABuildPaths.Configuration, "android", "bin", "classes.dex");
Assert.That(new FileInfo(dexFile), Does.Exist, $"File {dexFile} should exist");
Assert.That(DexUtils.ContainsClass("Lmono/android/app/XamarinAndroidEnvironmentVariables;", dexFile, androidSdkDir), Is.True, $"Dex file {dexFile} should contain the XamarinAndroidEnvironmentVariables class");
}
public void CheckBuildIdIsUnique()
{
Dictionary <string, string> buildIds = new Dictionary <string, string> ();
var proj = new XamarinAndroidApplicationProject()
{
IsRelease = true,
};
proj.SetProperty(proj.ReleaseProperties, "MonoSymbolArchive", "True");
proj.SetProperty(proj.ReleaseProperties, "DebugSymbols", "true");
proj.SetProperty(proj.ReleaseProperties, "DebugType", "PdbOnly");
proj.SetProperty(proj.ReleaseProperties, KnownProperties.AndroidCreatePackagePerAbi, "true");
proj.SetProperty(proj.ReleaseProperties, KnownProperties.AndroidSupportedAbis, "armeabi-v7a;x86");
using (var b = CreateApkBuilder(Path.Combine("temp", TestContext.CurrentContext.Test.Name))) {
b.Verbosity = Microsoft.Build.Framework.LoggerVerbosity.Diagnostic;
b.ThrowOnBuildFailure = false;
Assert.IsTrue(b.Build(proj), "first build failed");
var outputPath = Path.Combine(Root, b.ProjectDirectory, proj.OutputPath);
var archivePath = Path.Combine(outputPath, proj.PackageName + ".apk.mSYM");
var allFilesInArchive = Directory.GetFiles(archivePath, "*", SearchOption.AllDirectories);
string extension = "dll";
Assert.IsTrue(allFilesInArchive.Any(x => Path.GetFileName(x) == $"{proj.ProjectName}.{extension}"), $"{proj.ProjectName}.{extension} should exist in {archivePath}");
//NOTE: Windows is still generating mdb files here
extension = IsWindows ? "dll.mdb" : "pdb";
Assert.IsTrue(allFilesInArchive.Any(x => Path.GetFileName(x) == $"{proj.ProjectName}.{extension}"), $"{proj.ProjectName}.{extension} should exist in {archivePath}");
string javaEnv = Path.Combine(Root, b.ProjectDirectory,
proj.IntermediateOutputPath, "android", "src", "mono", "android", "app", "XamarinAndroidEnvironmentVariables.java");
Assert.IsTrue(File.Exists(javaEnv), $"Java environment source does not exist at {javaEnv}");
string[] lines = File.ReadAllLines(javaEnv);
Assert.IsTrue(lines.Any(x => x.Contains("\"XAMARIN_BUILD_ID\",")),
"The environment should contain a XAMARIN_BUILD_ID");
string buildID = lines.First(x => x.Contains("\"XAMARIN_BUILD_ID\","))
.Trim()
.Replace("\", \"", "=")
.Replace("\",", String.Empty)
.Replace("\"", String.Empty);
buildIds.Add("all", buildID);
string dexFile = Path.Combine(Root, b.ProjectDirectory, proj.IntermediateOutputPath, "android", "bin", "classes.dex");
Assert.IsTrue(File.Exists(dexFile), $"dex file does not exist at {dexFile}");
Assert.IsTrue(DexUtils.ContainsClass("Lmono/android/app/XamarinAndroidEnvironmentVariables;", dexFile, b.AndroidSdkDirectory),
$"dex file {dexFile} does not contain the XamarinAndroidEnvironmentVariables class");
var msymDirectory = Path.Combine(Root, b.ProjectDirectory, proj.OutputPath, proj.PackageName + ".apk.mSYM");
Assert.IsTrue(File.Exists(Path.Combine(msymDirectory, "manifest.xml")), "manifest.xml should exist in", msymDirectory);
var doc = XDocument.Load(Path.Combine(msymDirectory, "manifest.xml"));
Assert.IsTrue(doc.Element("mono-debug")
.Elements()
.Any(x => x.Name == "app-id" && x.Value == proj.PackageName), "app-id is has an incorrect value.");
var buildId = buildIds.First().Value;
Assert.IsTrue(doc.Element("mono-debug")
.Elements()
.Any(x => x.Name == "build-id" && x.Value == buildId.Replace("XAMARIN_BUILD_ID=", "")), "build-id is has an incorrect value.");
}
}
public void InstantRunSimpleBuild([Values("dx", "d8")] string dexTool)
{
if (!CommercialBuildAvailable)
{
Assert.Ignore("Not required on Open Source Builds");
}
if (!HasDevices)
{
Assert.Ignore("Test needs a device attached.");
return;
}
var proj = new XamarinFormsAndroidApplicationProject {
AndroidFastDeploymentType = "Assemblies:Dexes",
UseLatestPlatformSdk = true,
DexTool = dexTool,
};
var b = CreateApkBuilder(Path.Combine("temp", TestName));
Assert.IsTrue(b.Clean(proj), "Clean should have succeeded.");
Assert.IsTrue(b.Build(proj), "Build should have succeeded.");
var manifest = b.Output.GetIntermediaryAsText(BuildOutputFiles.AndroidManifest);
Assert.IsTrue(File.Exists(b.Output.GetIntermediaryPath("android/bin/dex/mono.android.dex")), "there should be mono.android.dex in the intermediaries.");
using (var apk = ((AndroidApplicationBuildOutput)b.Output).OpenApk()) {
var dexFile = Path.GetTempFileName();
File.WriteAllBytes(dexFile, apk.GetRaw(ApkContents.ClassesDex));
try {
string className = "Lcom/xamarin/forms/platform/android/FormsViewGroup;";
Assert.IsFalse(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should *not* include `{className}`!");
className = "Lmono/MonoRuntimeProvider;";
Assert.IsFalse(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should include `{className}`!");
className = "Lmono/MonoPackageManager;";
Assert.IsTrue(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should include `{className}`!");
} finally {
File.Delete(dexFile);
}
}
b.Dispose();
}
public void ChangePackageNamingPolicy()
{
var proj = new XamarinAndroidApplicationProject();
proj.Sources.Add(new BuildItem.Source("Bar.cs")
{
TextContent = () => "namespace Foo { class Bar : Java.Lang.Object { } }"
});
proj.SetProperty("AndroidPackageNamingPolicy", "LowercaseMD5");
using (var b = CreateApkBuilder()) {
Assert.IsTrue(b.Build(proj), "first build should have succeeded.");
var dexFile = b.Output.GetIntermediaryPath(Path.Combine("android", "bin", "classes.dex"));
var className = "Lmd5aaee5c01293e648941eac447719ef3fb/Bar;";
Assert.IsTrue(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should include `{className}`!");
proj.SetProperty("AndroidPackageNamingPolicy", "LowercaseCrc64");
Assert.IsTrue(b.Build(proj), "second build should have succeeded.");
Assert.IsFalse(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should *not* include `{className}`!");
className = "Lcrc64dca3aed1e0ff8a1a/Bar;";
Assert.IsTrue(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should include `{className}`!");
}
}
public void DotNetBuildLibrary(bool isRelease, bool duplicateAar)
{
var path = Path.Combine("temp", TestName);
var env_var = "MY_ENVIRONMENT_VAR";
var env_val = "MY_VALUE";
// Setup dependencies App A -> Lib B -> Lib C
var libC = new XASdkProject(outputType: "Library")
{
ProjectName = "LibraryC",
IsRelease = isRelease,
Sources =
{
new BuildItem.Source("Bar.cs")
{
TextContent = () => "public class Bar { }",
}
}
};
libC.OtherBuildItems.Add(new AndroidItem.AndroidAsset("Assets\\bar\\bar.txt")
{
BinaryContent = () => Array.Empty <byte> (),
});
var activity = libC.Sources.FirstOrDefault(s => s.Include() == "MainActivity.cs");
if (activity != null)
{
libC.Sources.Remove(activity);
}
var libCBuilder = CreateDotNetBuilder(libC, Path.Combine(path, libC.ProjectName));
Assert.IsTrue(libCBuilder.Build(), $"{libC.ProjectName} should succeed");
var libB = new XASdkProject(outputType: "Library")
{
ProjectName = "LibraryB",
IsRelease = isRelease,
Sources =
{
new BuildItem.Source("Foo.cs")
{
TextContent = () => "public class Foo : Bar { }",
}
}
};
libB.OtherBuildItems.Add(new AndroidItem.AndroidAsset("Assets\\foo\\foo.txt")
{
BinaryContent = () => Array.Empty <byte> (),
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidResource("Resources\\layout\\MyLayout.axml")
{
TextContent = () => "<?xml version=\"1.0\" encoding=\"utf-8\" ?><LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\" />"
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidResource("Resources\\raw\\bar.txt")
{
BinaryContent = () => Array.Empty <byte> (),
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidEnvironment("env.txt")
{
TextContent = () => $"{env_var}={env_val}",
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidEnvironment("sub\\directory\\env.txt")
{
TextContent = () => $"{env_var}={env_val}",
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidLibrary("sub\\directory\\foo.jar")
{
BinaryContent = () => Convert.FromBase64String(InlineData.JavaClassesJarBase64),
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidLibrary("sub\\directory\\arm64-v8a\\libfoo.so")
{
BinaryContent = () => Array.Empty <byte> (),
});
libB.OtherBuildItems.Add(new AndroidItem.AndroidLibrary("libfoo.so")
{
MetadataValues = "Link=x86\\libfoo.so",
BinaryContent = () => Array.Empty <byte> (),
});
libB.AddReference(libC);
activity = libB.Sources.FirstOrDefault(s => s.Include() == "MainActivity.cs");
if (activity != null)
{
libB.Sources.Remove(activity);
}
var libBBuilder = CreateDotNetBuilder(libB, Path.Combine(path, libB.ProjectName));
Assert.IsTrue(libBBuilder.Build(), $"{libB.ProjectName} should succeed");
// Check .aar file for class library
var aarPath = Path.Combine(FullProjectDirectory, libB.OutputPath, $"{libB.ProjectName}.aar");
FileAssert.Exists(aarPath);
using (var aar = ZipHelper.OpenZip(aarPath)) {
aar.AssertContainsEntry(aarPath, "assets/foo/foo.txt");
aar.AssertContainsEntry(aarPath, "res/layout/mylayout.xml");
aar.AssertContainsEntry(aarPath, "res/raw/bar.txt");
aar.AssertContainsEntry(aarPath, ".net/__res_name_case_map.txt");
aar.AssertContainsEntry(aarPath, ".net/env/190E30B3D205731E.env");
aar.AssertContainsEntry(aarPath, ".net/env/2CBDAB7FEEA94B19.env");
aar.AssertContainsEntry(aarPath, "libs/A1AFA985571E728E.jar");
aar.AssertContainsEntry(aarPath, "jni/arm64-v8a/libfoo.so");
aar.AssertContainsEntry(aarPath, "jni/x86/libfoo.so");
}
// Check EmbeddedResource files do not exist
var assemblyPath = Path.Combine(FullProjectDirectory, libB.OutputPath, $"{libB.ProjectName}.dll");
FileAssert.Exists(assemblyPath);
using (var assembly = AssemblyDefinition.ReadAssembly(assemblyPath)) {
Assert.AreEqual(0, assembly.MainModule.Resources.Count);
}
var appA = new XASdkProject {
ProjectName = "AppA",
IsRelease = isRelease,
Sources =
{
new BuildItem.Source("Bar.cs")
{
TextContent = () => "public class Bar : Foo { }",
}
}
};
appA.AddReference(libB);
if (duplicateAar)
{
// Test a duplicate @(AndroidLibrary) item with the same path of LibraryB.aar
appA.OtherBuildItems.Add(new AndroidItem.AndroidLibrary(aarPath));
}
var appBuilder = CreateDotNetBuilder(appA, Path.Combine(path, appA.ProjectName));
Assert.IsTrue(appBuilder.Build(), $"{appA.ProjectName} should succeed");
// Check .apk for assets, res, and native libraries
var apkPath = Path.Combine(FullProjectDirectory, appA.OutputPath, $"{appA.PackageName}.apk");
FileAssert.Exists(apkPath);
using (var apk = ZipHelper.OpenZip(apkPath)) {
apk.AssertContainsEntry(apkPath, "assets/foo/foo.txt");
apk.AssertContainsEntry(apkPath, "assets/bar/bar.txt");
apk.AssertContainsEntry(aarPath, "res/layout/mylayout.xml");
apk.AssertContainsEntry(apkPath, "res/raw/bar.txt");
apk.AssertContainsEntry(apkPath, "lib/arm64-v8a/libfoo.so");
apk.AssertContainsEntry(apkPath, "lib/x86/libfoo.so");
}
// Check classes.dex contains foo.jar
var intermediate = Path.Combine(FullProjectDirectory, appA.IntermediateOutputPath);
var dexFile = Path.Combine(intermediate, "android", "bin", "classes.dex");
FileAssert.Exists(dexFile);
string className = "Lcom/xamarin/android/test/msbuildtest/JavaSourceJarTest;";
Assert.IsTrue(DexUtils.ContainsClass(className, dexFile, AndroidSdkPath), $"`{dexFile}` should include `{className}`!");
// Check environment variable
var environmentFiles = EnvironmentHelper.GatherEnvironmentFiles(intermediate, "x86", required: true);
var environmentVariables = EnvironmentHelper.ReadEnvironmentVariables(environmentFiles);
Assert.IsTrue(environmentVariables.TryGetValue(env_var, out string actual), $"Environment should contain {env_var}");
Assert.AreEqual(env_val, actual, $"{env_var} should be {env_val}");
// Check Resource.designer.cs
var resource_designer_cs = Path.Combine(intermediate, "Resource.designer.cs");
FileAssert.Exists(resource_designer_cs);
var resource_designer_text = File.ReadAllText(resource_designer_cs);
StringAssert.Contains("public const int MyLayout", resource_designer_text);
}