IncrementalBuildTest.cs

using Microsoft.Build.Framework;
using Mono.Cecil;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Xamarin.Android.Tasks;
using Xamarin.ProjectTools;
using Microsoft.Android.Build.Tasks;

namespace Xamarin.Android.Build.Tests
{
	[Parallelizable (ParallelScope.Children)]
	public class IncrementalBuildTest : BaseTest
	{
		[Test]
		public void BasicApplicationRepetitiveBuild ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);

			using (var b = CreateApkBuilder ()) {
				b.ThrowOnBuildFailure = false;
				Assert.IsTrue (b.Build (proj), "first build failed");
				var firstBuildTime = b.LastBuildTime;
				Assert.IsTrue (b.Build (proj), "second build failed");
				if (runtime != AndroidRuntime.NativeAOT) {
					Assert.IsTrue (
						firstBuildTime > b.LastBuildTime, "Second build ({0}) should have been faster than the first ({1})",
						b.LastBuildTime, firstBuildTime
					);
				}
				Assert.IsTrue (
					b.Output.IsTargetSkipped ("_Sign"),
					"the _Sign target should not run");
				var item = proj.AndroidResources.First (x => x.Include () == "Resources\\values\\Strings.xml");
				item.TextContent = () => proj.StringsXml.Replace ("${PROJECT_NAME}", "Foo");
				item.Timestamp = null;
				Assert.IsTrue (b.Build (proj), "third build failed");
				Assert.IsFalse (
					b.Output.IsTargetSkipped ("_Sign"),
					"the _Sign target should run");
			}
		}

		// TODO: fix for CoreCLR, currently fails with
		//
		//   The target _Sign should have *not* been skipped.
		//
		// TODO: fix for NativeAOT, currently fails with
		//   The target _RunILLink should have been skipped.
		//
		[Test]
		public void BasicApplicationRepetitiveReleaseBuild ([Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			if (runtime != AndroidRuntime.MonoVM) { // temporarily
				Assert.Ignore ("Runtimes other than MonoVM are currently broken here.");
			}

			var proj = new XamarinAndroidApplicationProject () { IsRelease = isRelease };
			using (var b = CreateApkBuilder ()) {
				var foo = new BuildItem.Source ("Foo.cs") {
					TextContent = () => @"using System;
	namespace UnnamedProject {
		public class Foo {
		}
	}"
				};

				proj.SetRuntime (runtime);
				proj.Sources.Add (foo);
				Assert.IsTrue (b.Build (proj), "first build failed");
				var firstBuildTime = b.LastBuildTime;
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "second build failed");
				Assert.IsTrue (
					firstBuildTime > b.LastBuildTime, "Second build ({0}) should have been faster than the first ({1})",
					b.LastBuildTime, firstBuildTime
				);
				b.Output.AssertTargetIsSkipped ("_Sign");
				b.Output.AssertTargetIsSkipped (KnownTargets.LinkAssembliesShrink);
				proj.Touch ("Foo.cs");
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "third build failed");
				b.Output.AssertTargetIsNotSkipped ("CoreCompile");
				b.Output.AssertTargetIsNotSkipped ("_Sign");
				b.Output.AssertTargetIsPartiallyBuilt ("_CompressAssemblies");
			}
		}

		[Test]
		public void CheckNothingIsDeletedByIncrementalClean ([Values] bool enableMultiDex, [Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			// TODO: NativeAOT fails the App1.csproj.FileListAbsolute.txt contents check. It adds some entries, needs verification
			//       if it's a correct behavior or not.
			if (runtime == AndroidRuntime.NativeAOT) {
				Assert.Ignore ("NativeAOT fails the App1.csproj.FileListAbsolute.txt contents check");
			}

			var path = Path.Combine ("temp", TestName);
			var proj = new XamarinFormsAndroidApplicationProject () {
				ProjectName = "App1",
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			if (enableMultiDex)
				proj.SetProperty ("AndroidEnableMultiDex", "True");
			using (var b = CreateApkBuilder (path)) {
				//To be sure we are at a clean state
				var projectDir = Path.Combine (Root, b.ProjectDirectory);
				if (Directory.Exists (projectDir))
					Directory.Delete (projectDir, true);

				Assert.IsTrue (b.Build (proj), "First should have succeeded" );
				var intermediate = Path.Combine (projectDir, proj.IntermediateOutputPath);
				var output = Path.Combine (projectDir, proj.OutputPath);
				var fileWrites = Path.Combine (intermediate, $"{proj.ProjectName}.csproj.FileListAbsolute.txt");
				FileAssert.Exists (fileWrites);
				var expected = File.ReadAllText (fileWrites);
				var files = Directory.EnumerateFiles (intermediate, "*", SearchOption.AllDirectories).ToList ();
				files.AddRange (Directory.EnumerateFiles (output, "*", SearchOption.AllDirectories));

				//Touch a few files, do an incremental build
				var filesToTouch = new [] {
 					Path.Combine (intermediate, "build.props"),
 					Path.Combine (intermediate, $"{proj.ProjectName}.pdb"),
 				};
				foreach (var file in filesToTouch) {
					FileAssert.Exists (file);
					File.SetLastWriteTimeUtc (file, DateTime.UtcNow);
				}
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "Second should have succeeded");
				b.Output.AssertTargetIsNotSkipped ("_CleanMonoAndroidIntermediateDir");
				var stampFiles = Path.Combine (intermediate, "stamp", "_ResolveLibraryProjectImports.stamp");
				FileAssert.Exists (stampFiles, $"{stampFiles} should exist!");
				var libraryProjectImports = Path.Combine (intermediate, "libraryprojectimports.cache");
				FileAssert.Exists (libraryProjectImports, $"{libraryProjectImports} should exist!");

				//No changes
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "Third should have succeeded");
				Assert.IsFalse (b.Output.IsTargetSkipped ("IncrementalClean"), "`IncrementalClean` should have run!");
				foreach (var file in files) {
					FileAssert.Exists (file, $"{file} should not have been deleted!" );
				}
				FileAssert.Exists (fileWrites);
				var actual = File.ReadAllText (fileWrites);
				Assert.AreEqual (expected, actual, $"`{fileWrites}` has changes!");
			}
		}

		[Test]
		public void CheckResourceDirectoryDoesNotGetHosed ([Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			// do a release build
			// change one of the properties (say AotAssemblies)
			// do another build. it should NOT hose the resource directory.
			var proj = new XamarinAndroidApplicationProject () {
				ProjectName = "App1",
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue(b.Build (proj), "First should have succeeded");
				Assert.IsFalse (
					b.Output.IsTargetSkipped ("_GenerateAndroidResourceDir"),
					"the _GenerateAndroidResourceDir target should not be skipped");
				File.SetLastWriteTimeUtc (Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath, "build.props"),
					DateTime.UtcNow);
				Assert.IsTrue(b.Build (proj), "Second should have succeeded");
				Assert.IsFalse (
					b.Output.IsTargetSkipped ("_GenerateAndroidResourceDir"),
					"the _GenerateAndroidResourceDir target should not be skipped");
			}
		}

		[Test]
		public void IncrementalCleanDuringClean ([Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject () {
				ProjectName = "App1",
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			proj.SetProperty ("AndroidUseManagedDesignTimeResourceGenerator", "True");
			proj.SetProperty ("AndroidUseDesignerAssembly", "False");
			using (var b = CreateApkBuilder ()) {
				b.Target = "Compile";
				Assert.IsTrue(b.Build (proj), "DesignTime Build should have succeeded");
				var designTimeDesigner = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath, "designtime", "Resource.designer.cs");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should have been created.");
				b.Target = "Build";
				Assert.IsTrue(b.Build (proj), "Build should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after Build.");
				b.Target = "Clean";
				Assert.IsTrue(b.Build (proj), "Clean should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after Clean.");
				b.Target = "Compile";
				Assert.IsTrue(b.Build (proj), "Build should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after Compile.");
				b.Target = "Build";
				Assert.IsTrue(b.Build (proj), "Build should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after second Build.");
				Assert.IsTrue(b.Build (proj), "Build should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after third Build.");
				b.Target = "Compile";
				Assert.IsTrue(b.Build (proj), "Build should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after second Compile.");
				b.Target = "Clean";
				Assert.IsTrue(b.Build (proj), "Clean should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after second Clean.");
				b.Target = "ReBuild";
				Assert.IsTrue(b.Build (proj), "ReBuild should have succeeded");
				FileAssert.Exists (designTimeDesigner, $"{designTimeDesigner} should still exist after ReBuild.");
			}

		}

		[Test]
		public void LibraryIncrementalBuild ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var lib = new XamarinAndroidLibraryProject {
				IsRelease = isRelease,
				ProjectName = "Lib",
				Sources = {
					new BuildItem.Source ("Class1.cs") {
						TextContent = () => "public class Class1 { }",
					}
				},
			};
			lib.SetRuntime (runtime);
			using (var b = CreateDllBuilder ()) {
				Assert.IsTrue (b.Build (lib), "first build should have succeeded.");
				var aarPath = Path.Combine (Root, b.ProjectDirectory, lib.OutputPath, $"{lib.ProjectName}.aar");
				FileAssert.Exists (aarPath);
				lib.Touch ("Class1.cs");
				Assert.IsTrue (b.Build (lib), "second build should have succeeded.");
				FileAssert.Exists (aarPath);
			}
		}

		[Test]
		public void AllProjectsHaveSameOutputDirectory ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var testPath = Path.Combine ("temp", TestName);
			var sb = new SolutionBuilder ("AllProjectsHaveSameOutputDirectory.sln") {
				SolutionPath = Path.Combine (Root, testPath),
			};

			var app1 = new XamarinAndroidApplicationProject () {
				IsRelease = isRelease,
				ProjectName = "App1",
				PackageName = "com.companyname.App1",
				OutputPath = Path.Combine ("..","bin","Debug"),
			};
			app1.SetRuntime (runtime);
			sb.Projects.Add (app1);
			var app2 = new XamarinAndroidApplicationProject () {
				IsRelease = isRelease,
				ProjectName = "App2",
				PackageName = "com.companyname.App2",
				OutputPath = Path.Combine ("..","bin","Debug"),
			};
			app2.SetRuntime (runtime);
			sb.Projects.Add (app2);
			Assert.IsTrue (sb.Build (), "Build of solution should have succeeded");
			Assert.IsTrue (sb.ReBuild (), "ReBuild of solution should have succeeded");
			sb.Dispose ();
		}

		[Test]
		public void BuildSolutionWithMultipleProjectsInParallel ([Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var testPath = Path.Combine ("temp", TestName);
			var sb = new SolutionBuilder("BuildSolutionWithMultipleProjects.sln") {
				SolutionPath = Path.Combine (Root, testPath),
				MaxCpuCount = 4,
			};

			bool aotAssemblies = runtime switch {
				AndroidRuntime.MonoVM  => true,
				AndroidRuntime.CoreCLR => false,
				AndroidRuntime.NativeAOT => false,
				_                      => throw new NotSupportedException ($"Unsupported runtime '{runtime}'")
			};

			for (int i=1; i <= 4; i++) {
				var app1 = new XamarinAndroidApplicationProject () {
					ProjectName = $"App{i}",
					PackageName = $"com.companyname.App{i}",
					AotAssemblies = aotAssemblies,
					IsRelease = isRelease,
					EnableMarshalMethods = true,
				};

				app1.SetRuntime (runtime);
				sb.Projects.Add (app1);
			}
			sb.BuildingInsideVisualStudio = false;
			Assert.IsTrue (sb.Build (), "Build of solution should have succeeded");
			Assert.IsTrue (sb.ReBuild (), "ReBuild of solution should have succeeded");
			sb.Dispose ();
		}

		[Test]
		public void JavacTaskDoesNotRunOnSecondBuild ([Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var app = new XamarinAndroidApplicationProject () {
				IsRelease = isRelease,
				ProjectName = "App",
				OtherBuildItems = {
					new AndroidItem.AndroidJavaSource ("TestMe.java") {
						TextContent = () => @"package com.android.test;
public class TestMe {
	public TestMe createTestMe () {
		return new TestMe ();
	}
}",
						Encoding = Encoding.ASCII,
						MetadataValues = "Bind=False",
					}
				},
			};
			app.SetRuntime (runtime);

			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (app), "First build should have succeeded");
				Assert.IsFalse (
					b.Output.IsTargetSkipped ("_CompileJava"),
					"the _CompileJava target should not be skipped");
				Assert.IsFalse (
					b.Output.IsTargetSkipped ("_BuildApkEmbed"),
					"the _BuildApkEmbed target should not be skipped");
				var expectedOutput = Path.Combine (Root, b.ProjectDirectory, app.IntermediateOutputPath, "android", "bin", "classes",
					"com", "android", "test", "TestMe.class");
				Assert.IsTrue (File.Exists (expectedOutput), string.Format ("{0} should exist.", expectedOutput));
				Assert.IsTrue (b.Build (app), "Second build should have succeeded");
				Assert.IsTrue (
					b.Output.IsTargetSkipped ("_CompileJava"),
					"the _CompileJava target should be skipped");
				Assert.IsTrue (
					b.Output.IsTargetSkipped ("_BuildApkEmbed"),
					"the _BuildApkEmbed target should be skipped");
				Assert.IsTrue (File.Exists (expectedOutput), string.Format ("{0} should exist.", expectedOutput));
			}
		}

		[Test]
		public void ResolveNativeLibrariesInManagedReferences ([Values] AndroidRuntime runtime)
		{
			const bool isRelease = true;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			string abi = runtime switch {
				AndroidRuntime.MonoVM => "armeabi-v7a",
				AndroidRuntime.CoreCLR => "arm64-v8a",
				AndroidRuntime.NativeAOT => "arm64-v8a",
				_ => throw new NotSupportedException ($"Unsupported runtime '{runtime}'")
			};

			var lib = new XamarinAndroidLibraryProject () {
				ProjectName = "Lib",
				IsRelease = isRelease,
				ProjectGuid = Guid.NewGuid ().ToString (),
				OtherBuildItems = {
					new BuildItem (AndroidBuildActions.EmbeddedNativeLibrary, $"libs/{abi}/libfoo.so") {
						TextContent = () => string.Empty,
						Encoding = Encoding.ASCII,
					}
				},
				Sources = {
					new BuildItem.Source ("Class1.cs") {
						TextContent= () => @"
using System;
namespace Lib
{
	public class Class1
	{
		public Class1 ()
		{
		}
	}
}"
					},
				},
			};
			lib.SetRuntime (runtime);
			var so = lib.OtherBuildItems.First (x => x.Include () == $"libs/{abi}/libfoo.so");

			var lib2 = new XamarinAndroidLibraryProject () {
				ProjectName = "Lib2",
				ProjectGuid = Guid.NewGuid ().ToString (),
				IsRelease = isRelease,
				OtherBuildItems = {
					new BuildItem (AndroidBuildActions.EmbeddedNativeLibrary, $"libs/{abi}/libfoo2.so") {
						TextContent = () => string.Empty,
						Encoding = Encoding.ASCII,
					},
					new BuildItem.ProjectReference (@"..\Lib\Lib.csproj", "Lib", lib.ProjectGuid) {
					}
				},
				Sources = {
					new BuildItem.Source ("Class2.cs") {
						TextContent= () => @"
using System;
namespace Lib2
{
	public class Class2
	{
		public Class2 ()
		{
			var c = new Lib.Class1 ();
		}
	}
}"
					},
				},
			};
			lib2.SetRuntime (runtime);
			var path = Path.Combine (Root, "temp", TestName);
			using (var libbuilder = CreateDllBuilder (Path.Combine (path, "Lib"))) {

				Assert.IsTrue (libbuilder.Build (lib), "lib 1st. build failed");

				using (var libbuilder2 = CreateDllBuilder (Path.Combine (path, "Lib2"))) {

					Assert.IsTrue (libbuilder2.Build (lib2), "lib 1st. build failed");

					var app = new XamarinAndroidApplicationProject () { ProjectName = "App",
						IsRelease = isRelease,
						OtherBuildItems = {
							new BuildItem.ProjectReference (@"..\Lib2\Lib2.csproj", "Lib2", lib2.ProjectGuid),
						}
					};
					app.SetRuntime (runtime);

					if (runtime == AndroidRuntime.MonoVM) {
						// Using `SetRuntimeIdentifier` would change the intermediate path (by adding the RID component to it) and, thus, the way this test used to work.
						// Keep it as it was.
						app.SetAndroidSupportedAbis (abi);
					} else {
						app.SetRuntimeIdentifier (abi);
					}

					using (var builder = CreateApkBuilder (Path.Combine (path, "App"))) {
						Assert.IsTrue (builder.Build (app), "app 1st. build failed");

						// TODO: appending of the RID to the output path should probably be fixed in the project class instead of here (and elsewhere)
						string apkFile = Path.Combine (Root, builder.ProjectDirectory, app.OutputPath);
						if (runtime == AndroidRuntime.CoreCLR || runtime == AndroidRuntime.NativeAOT) {
							apkFile = Path.Combine (apkFile, MonoAndroidHelper.AbiToRid (abi));
						}
						apkFile = Path.Combine (apkFile, app.PackageName + "-Signed.apk");

						var libfoo = ZipHelper.ReadFileFromZip (apkFile, $"lib/{abi}/libfoo.so");
						Assert.IsNotNull (libfoo, "libfoo.so should exist in the .apk");

						so.TextContent = () => "newValue";
						so.Timestamp = DateTimeOffset.UtcNow;
						Assert.IsTrue (libbuilder.Build (lib), "lib 2nd. build failed");
						Assert.IsTrue (libbuilder2.Build (lib2), "lib 2nd. build failed");
						Assert.IsTrue (builder.Build (app), "app 2nd. build failed");

						Assert.IsNotNull (libfoo, "libfoo.so should exist in the .apk");

						libfoo = ZipHelper.ReadFileFromZip (apkFile, $"lib/{abi}/libfoo.so");
						Assert.AreEqual (so.TextContent ().Length, libfoo.Length, "compressed size mismatch");
						var libfoo2 = ZipHelper.ReadFileFromZip (apkFile, $"lib/{abi}/libfoo2.so");
						Assert.IsNotNull (libfoo2, "libfoo2.so should exist in the .apk");
						Directory.Delete (path, recursive: true);
					}
				}
			}
		}

		//https://github.com/xamarin/xamarin-android/issues/2247
		[Test]
		[NonParallelizable] // Do not run timing sensitive tests in parallel
		public void AppProjectTargetsDoNotBreak ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var targets = new List<(string target, bool ignoreOnNAOT)> {
				("_GeneratePackageManagerJava", true), // TODO: NativeAOT doesn't skip this target on 3rd attempt, check if that's ok?
				("_ResolveLibraryProjectImports", false),
				("_CleanIntermediateIfNeeded", false),
			};

			var proj = new XamarinFormsAndroidApplicationProject {
				IsRelease = isRelease,
				OtherBuildItems = {
					new BuildItem.NoActionResource ("UnnamedProject.dll.config") {
						TextContent = () => "<?xml version='1.0' ?><configuration/>",
						Metadata = {
							{ "CopyToOutputDirectory", "PreserveNewest"},
						}
					}
				}
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should succeed");
				var firstBuildTime = b.LastBuildTime;
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target.target), $"`{target}` should *not* be skipped!");
				}

				var output = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath);
				var intermediate = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath);
				var filesToTouch = new List<string> {
					Path.Combine (intermediate, "..", "project.assets.json"),
					Path.Combine (intermediate, "build.props"),
					Path.Combine (intermediate, $"{proj.ProjectName}.dll"),
					Path.Combine (intermediate, $"{proj.ProjectName}.pdb"),
					Path.Combine (output, $"{proj.ProjectName}.dll.config"),
				};

				foreach (string abi in proj.GetRuntimeIdentifiersAsAbis ()) {
					if (runtime != AndroidRuntime.NativeAOT) {
						filesToTouch.Add (Path.Combine (intermediate, "android", "assets", abi, $"{proj.ProjectName}.dll"));
					} else {
						filesToTouch.Add (Path.Combine (intermediate, MonoAndroidHelper.AbiToRid (abi), "linked", $"{proj.ProjectName}.dll"));
					}
				}

				foreach (var file in filesToTouch) {
					FileAssert.Exists (file);
					File.SetLastWriteTimeUtc (file, DateTime.UtcNow);
				}

				//NOTE: second build, targets will run because inputs changed
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "second build should succeed");
				var secondBuildTime = b.LastBuildTime;
				foreach (var target in targets) {
					b.Output.AssertTargetIsNotSkipped (target.target);
				}

				//NOTE: third build, targets should certainly *not* run! there are no changes
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "third build should succeed");
				var thirdBuildTime = b.LastBuildTime;
				foreach (var target in targets) {
					if (runtime == AndroidRuntime.NativeAOT && target.ignoreOnNAOT) {
						continue;
					}

					b.Output.AssertTargetIsSkipped (target.target);
				}
				if (runtime != AndroidRuntime.NativeAOT) {
					Assert.IsTrue (thirdBuildTime < firstBuildTime, $"Third unchanged build: '{thirdBuildTime}' should be faster than clean build: '{firstBuildTime}'.");
					Assert.IsTrue (thirdBuildTime < secondBuildTime, $"Third unchanged build: '{thirdBuildTime}' should be faster than partially incremental second build: '{secondBuildTime}'.");
				}
			}
		}

		[Test]
		public void LibraryProjectTargetsDoNotBreak ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var targets = new [] {
				"_CreateAar",
			};

			var proj = new XamarinAndroidLibraryProject {
				IsRelease = isRelease,
				Sources = {
					new BuildItem.Source ("Class1.cs") {
						TextContent= () => "public class Class1 { }"
					},
				},
				OtherBuildItems = {
					new AndroidItem.EmbeddedNativeLibrary ("foo\\armeabi-v7a\\libtest.so") {
						BinaryContent = () => new byte [10],
						MetadataValues = "Link=libs\\armeabi-v7a\\libtest.so",
					},
					new AndroidItem.EmbeddedNativeLibrary ("foo\\x86\\libtest.so") {
						BinaryContent = () => new byte [10],
						MetadataValues = "Link=libs\\x86\\libtest.so",
					},
					new AndroidItem.AndroidAsset ("Assets\\foo.txt") {
						TextContent =  () => "bar",
					},
				},
			};
			proj.SetRuntime (runtime);
			using (var b = CreateDllBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should succeed");
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped!");
				}

				WaitFor (1000);
				proj.Touch ("foo\\armeabi-v7a\\libtest.so");
				proj.Touch ("Assets\\foo.txt");

				//NOTE: second build, targets will run because inputs changed
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "second build should succeed");
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped on second build!");
				}

				//NOTE: third build, targets should certainly *not* run! there are no changes
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "third build should succeed");
				foreach (var target in targets) {
					Assert.IsTrue (b.Output.IsTargetSkipped (target), $"`{target}` should be skipped on third build!");
				}
			}
		}

		[Test]
		public void ManifestMergerIncremental ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				ManifestMerger = "manifestmerger.jar"
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should succeed");
				b.Output.AssertTargetIsNotSkipped ("_ManifestMerger");

				// Change .csproj & build again
				proj.SetProperty ("Foo", "Bar");
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "second build should succeed");
				b.Output.AssertTargetIsNotSkipped ("_ManifestMerger");

				// Build with no changes
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "third build should succeed");
				b.Output.AssertTargetIsSkipped ("_ManifestMerger");
			}
		}

		[Test]
		public void ProduceReferenceAssembly ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			if (runtime == AndroidRuntime.NativeAOT) {
				// Fails on NativeAOT with:
				// Microsoft.NET.Sdk.FrameworkReferenceResolution.targets(120,5): error NETSDK1207: Ahead-of-time compilation is not supported for the target framework.
				Assert.Ignore ("NativeAOT doesn't support producing reference assemblies.");
			}

			var path = Path.Combine ("temp", TestName);
			var app = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				ProjectName = "MyApp",
				//NOTE: so _BuildApkEmbed runs in commercial tests
				EmbedAssembliesIntoApk = true,
				Sources = {
					new BuildItem.Source ("Foo.cs") {
						TextContent = () => "public class Foo : Bar { }"
					},
				}
			};

			app.SetRuntime (runtime);

			int count = 0;
			var lib = new DotNetStandard {
				IsRelease = isRelease,
				ProjectName = "MyLibrary",
				Sdk = "Microsoft.NET.Sdk",
				TargetFramework = "netstandard2.0",
				Sources = {
					new BuildItem.Source ("Bar.cs") {
						TextContent = () => "public class Bar { public Bar () { System.Console.WriteLine (" + count++ + "); } }"
					},
				}
			};
			lib.SetRuntime (runtime);
			lib.SetProperty ("ProduceReferenceAssembly", "True");
			app.References.Add (new BuildItem.ProjectReference ($"..\\{lib.ProjectName}\\{lib.ProjectName}.csproj", lib.ProjectName, lib.ProjectGuid));

			using (var libBuilder = CreateDllBuilder (Path.Combine (path, lib.ProjectName), false))
			using (var appBuilder = CreateApkBuilder (Path.Combine (path, app.ProjectName))) {
				Assert.IsTrue (libBuilder.Build (lib), "first library build should have succeeded.");
				Assert.IsTrue (appBuilder.Build (app), "first app build should have succeeded.");

				lib.Touch ("Bar.cs");

				Assert.IsTrue (libBuilder.Build (lib, doNotCleanupOnUpdate: true, saveProject: false), "second library build should have succeeded.");
				Assert.IsTrue (appBuilder.Build (app, doNotCleanupOnUpdate: true, saveProject: false), "second app build should have succeeded.");

				appBuilder.Output.AssertTargetIsSkipped ("CoreCompile");
				appBuilder.Output.AssertTargetIsSkipped ("_BuildLibraryImportsCache");
				appBuilder.Output.AssertTargetIsSkipped ("_ResolveLibraryProjectImports");
				appBuilder.Output.AssertTargetIsSkipped ("_GenerateJavaStubs");

				appBuilder.Output.AssertTargetIsPartiallyBuilt (KnownTargets.LinkAssembliesNoShrink);

				appBuilder.Output.AssertTargetIsNotSkipped ("_BuildApkEmbed");
				appBuilder.Output.AssertTargetIsNotSkipped ("_CopyPackage");
				appBuilder.Output.AssertTargetIsNotSkipped ("_Sign");
			}
		}

		[Test]
		public void TransitiveDependencyProduceReferenceAssembly ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var path = Path.Combine (Root, "temp", TestName);
			var app = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				ProjectName = "App",
				Sources = {
					new BuildItem.Source ("Class1.cs") {
						TextContent = () => "public class Class1 : Library1.Class1 { }"
					},
				}
			};
			app.SetRuntime (runtime);
			var lib1 = new DotNetStandard {
				IsRelease = isRelease,
				ProjectName = "Library1",
				Sdk = "Microsoft.NET.Sdk",
				TargetFramework = "netstandard2.0",
				Sources = {
					new BuildItem.Source ("Class1.cs") {
						TextContent = () => "namespace Library1 { public class Class1 { } }"
					},
					new BuildItem.Source ("Class2.cs") {
						TextContent = () => "namespace Library1 { public class Class2 : Library2.Class1 { } }"
					}
				}
			};
			if (runtime != AndroidRuntime.NativeAOT) { // NativeAOT cannot build reference assemblies
				lib1.SetRuntime (runtime);
			}
			lib1.SetProperty ("ProduceReferenceAssembly", "True");
			var lib2 = new DotNetStandard {
				IsRelease = isRelease,
				ProjectName = "Library2",
				Sdk = "Microsoft.NET.Sdk",
				TargetFramework = "netstandard2.0",
				Sources = {
					new BuildItem.Source ("Class1.cs") {
						TextContent = () => "namespace Library2 { public class Class1 { } }"
					},
				}
			};
			if (runtime != AndroidRuntime.NativeAOT) { // NativeAOT cannot build netstandard libraries
				lib2.SetRuntime (runtime);
			}
			lib2.SetProperty ("ProduceReferenceAssembly", "True");
			lib1.OtherBuildItems.Add (new BuildItem.ProjectReference ($"..\\{lib2.ProjectName}\\{lib2.ProjectName}.csproj", lib2.ProjectName, lib2.ProjectGuid));
			app.References.Add (new BuildItem.ProjectReference ($"..\\{lib1.ProjectName}\\{lib1.ProjectName}.csproj", lib1.ProjectName, lib1.ProjectGuid));

			using (var lib2Builder = CreateDllBuilder (Path.Combine (path, lib2.ProjectName), cleanupAfterSuccessfulBuild: false))
			using (var lib1Builder = CreateDllBuilder (Path.Combine (path, lib1.ProjectName), cleanupAfterSuccessfulBuild: false))
			using (var appBuilder = CreateApkBuilder (Path.Combine (path, app.ProjectName))) {
				Assert.IsTrue (lib2Builder.Build (lib2), "first Library2 build should have succeeded.");
				Assert.IsTrue (lib1Builder.Build (lib1), "first Library1 build should have succeeded.");
				Assert.IsTrue (appBuilder.Build (app), "first app build should have succeeded.");

				lib2.Sources.Add (new BuildItem.Source ("Class2.cs") {
					TextContent = () => "namespace Library2 { public class Class2 { } }"
				});

				Assert.IsTrue (lib2Builder.Build (lib2, doNotCleanupOnUpdate: true), "second Library2 build should have succeeded.");
				Assert.IsTrue (lib1Builder.Build (lib1, doNotCleanupOnUpdate: true, saveProject: false), "second Library1 build should have succeeded.");
				appBuilder.Target = "SignAndroidPackage";
				Assert.IsTrue (appBuilder.Build (app, doNotCleanupOnUpdate: true, saveProject: false), "app SignAndroidPackage build should have succeeded.");

				var lib2Output = Path.Combine (path, lib2.ProjectName, "bin", isRelease ? "Release" : "Debug", "netstandard2.0", $"{lib2.ProjectName}.dll");

				if (runtime != AndroidRuntime.NativeAOT) { // NativeAOT doesn't produce per-abi assets
					foreach (string abi in app.GetRuntimeIdentifiersAsAbis ()) {
						var lib2InAppOutput = Path.Combine (path, app.ProjectName, app.IntermediateOutputPath, "android", "assets", abi, $"{lib2.ProjectName}.dll");
						FileAssert.AreEqual (lib2Output, lib2InAppOutput, $"new Library2 should have been copied to app output directory for abi '{abi}'");
					}
				}
			}
		}

		[Test]
		public void LinkAssembliesNoShrink ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			var proj = new XamarinFormsAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);

			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "build should have succeeded.");

				// Touch an assembly to a timestamp older than build.props
				foreach (string abi in proj.GetRuntimeIdentifiersAsAbis ()) {
					string formsViewGroupRelPath = runtime switch {
						AndroidRuntime.NativeAOT => Path.Combine (MonoAndroidHelper.AbiToRid (abi), "linked"),
						_ => Path.Combine ("android", "assets", abi)
					};
					var formsViewGroup = b.Output.GetIntermediaryPath (Path.Combine (formsViewGroupRelPath, "FormsViewGroup.dll"));
					File.SetLastWriteTimeUtc (formsViewGroup, new DateTime (1970, 1, 1));
				}
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "build should have succeeded.");
				b.Output.AssertTargetIsNotSkipped (KnownTargets.LinkAssembliesNoShrink);

				// No changes
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "build should have succeeded.");
				if (runtime != AndroidRuntime.NativeAOT) { // TODO: review if NativeAOT should skip it
					b.Output.AssertTargetIsSkipped (KnownTargets.LinkAssembliesNoShrink);
				}
			}
		}

		[Test]
		public void CSProjUserFileChanges ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			AssertCommercialBuild ();

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			var selectedDevice = "foo";
			var csproj_user_file = $"{proj.ProjectName}.csproj.user";
			proj.Sources.Add (new BuildItem.NoActionResource (csproj_user_file) {
				TextContent = () => $"<Project><PropertyGroup><SelectedDevice>{selectedDevice}</SelectedDevice></PropertyGroup></Project>"
			});
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");

				// Simulates a different device/emulator selection in the IDE
				selectedDevice = "bar";
				proj.Touch (csproj_user_file);

				Assert.IsTrue (b.Build (proj), "second build should have succeeded.");
				b.Output.AssertTargetIsSkipped ("_CompileJava");
				b.Output.AssertTargetIsSkipped ("_CompileToDalvik");
				b.Output.AssertTargetIsSkipped ("_Sign");
			}
		}

		[Test]
		[NonParallelizable] // /restore can fail on Mac in parallel
		public void ConvertCustomView ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var path = Path.Combine ("temp", TestName);
			var app = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				ProjectName = "MyApp",
				//NOTE: so _BuildApkEmbed runs in commercial tests
				EmbedAssembliesIntoApk = true,
				Sources = {
					new BuildItem.Source ("Foo.cs") {
						TextContent = () => "public class Foo : Bar { }"
					},
					new BuildItem.Source ("CustomTextView.cs") {
						TextContent = () =>
							@"using Android.Widget;
							using Android.Content;
							using Android.Util;
							namespace MyApp
							{
								public class CustomTextView : TextView
								{
									public CustomTextView(Context context, IAttributeSet attributes) : base(context, attributes)
									{
									}
								}
							}"
					}
				}
			};
			app.SetRuntime (runtime);
			// Use a custom view
			app.LayoutMain = app.LayoutMain.Replace ("</LinearLayout>", "<MyApp.CustomTextView android:id=\"@+id/myText\" android:text=\"à请\" /></LinearLayout>");

			int count = 0;
			var lib = new DotNetStandard {
				IsRelease = isRelease,
				ProjectName = "MyLibrary",
				Sdk = "Microsoft.NET.Sdk",
				TargetFramework = "netstandard2.0",
				Sources = {
					new BuildItem.Source ("Bar.cs") {
						TextContent = () => "public class Bar { public Bar () { System.Console.WriteLine (" + count++ + "); } }"
					},
				}
			};
			if (runtime != AndroidRuntime.NativeAOT) { // netstandard doesn't support AOT
				lib.SetRuntime (runtime);
			}
			//NOTE: this test is checking when $(ProduceReferenceAssembly) is False
			lib.SetProperty ("ProduceReferenceAssembly", "False");
			app.References.Add (new BuildItem.ProjectReference ($"..\\{lib.ProjectName}\\{lib.ProjectName}.csproj", lib.ProjectName, lib.ProjectGuid));

			using (var libBuilder = CreateDllBuilder (Path.Combine (path, lib.ProjectName), false))
			using (var appBuilder = CreateApkBuilder (Path.Combine (path, app.ProjectName))) {
				appBuilder.Verbosity = LoggerVerbosity.Detailed;
				libBuilder.BuildLogFile = "build.log";
				Assert.IsTrue (libBuilder.Build (lib), "first library build should have succeeded.");
				appBuilder.BuildLogFile = "build.log";
				Assert.IsTrue (appBuilder.Build (app), "first app build should have succeeded.");

				var aapt2TargetsShouldRun = new [] {
					"_FixupCustomViewsForAapt2",
					"_CompileResources"
				};
				foreach (var target in aapt2TargetsShouldRun) {
					Assert.IsFalse (appBuilder.Output.IsTargetSkipped (target), $"{target} should run!");
				}

				lib.Touch ("Bar.cs");

				libBuilder.BuildLogFile = "build2.log";
				Assert.IsTrue (libBuilder.Build (lib, doNotCleanupOnUpdate: true, saveProject: false), "second library build should have succeeded.");
				appBuilder.BuildLogFile = "build2.log";
				Assert.IsTrue (appBuilder.Build (app, doNotCleanupOnUpdate: true, saveProject: false), "second app build should have succeeded.");

				var targetsShouldSkip = new [] {
					"_BuildLibraryImportsCache",
					"_ResolveLibraryProjectImports",
					"_ConvertCustomView",
				};
				foreach (var target in targetsShouldSkip) {
					Assert.IsTrue (appBuilder.Output.IsTargetSkipped (target), $"`{target}` should be skipped!");
				}

				var targetsShouldRun = new [] {
					//MyLibrary.dll changed and $(ProduceReferenceAssembly)=False
					"CoreCompile",
					"_GenerateJavaStubs",
					"_BuildApkEmbed",
					"_CopyPackage",
					"_Sign",
				};
				foreach (var target in targetsShouldRun) {
					Assert.IsFalse (appBuilder.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped!");
				}

				var aapt2TargetsShouldBeSkipped = new [] {
					"_FixupCustomViewsForAapt2",
					"_CompileResources"
				};
				foreach (var target in aapt2TargetsShouldBeSkipped) {
					Assert.IsTrue (appBuilder.Output.IsTargetSkipped (target, defaultIfNotUsed: true), $"{target} should be skipped!");
				}
			}
		}

		[Test]
		public void ResolveLibraryProjectImports ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinFormsAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);

			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");
				var intermediate = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath);
				var cacheFile = Path.Combine (intermediate, "libraryprojectimports.cache");
				FileAssert.Exists (cacheFile);
				var expected = ReadCache (cacheFile);
				Assert.AreNotEqual (0, expected.Jars.Length,
					$"{nameof (expected.Jars)} should not be empty");
				Assert.AreNotEqual (0, expected.ResolvedResourceDirectories.Length,
					$"{nameof (expected.ResolvedResourceDirectories)} should not be empty");
				Assert.AreNotEqual (0, expected.ResolvedResourceDirectoryStamps.Length,
					$"{nameof (expected.ResolvedResourceDirectoryStamps)} should not be empty");

				// Delete the stamp file; this triggers <ResolveLibraryProjectImports/> to re-run.
				// However, the task will skip everything, since the hashes of each assembly will be the same.
				var stamp = Path.Combine (intermediate, "stamp", "_ResolveLibraryProjectImports.stamp");
				FileAssert.Exists (stamp);
				File.Delete (stamp);

				b.BuildLogFile = "build2.log";
				Assert.IsTrue (b.Build (proj), "second build should have succeeded.");
				b.Output.AssertTargetIsNotSkipped ("_ResolveLibraryProjectImports");
				FileAssert.Exists (cacheFile);
				var actual = ReadCache (cacheFile);
				CollectionAssert.AreEqual (actual.Jars.Select (j => j.ItemSpec).OrderBy (j => j),
					expected.Jars.Select (j => j.ItemSpec).OrderBy (j => j));
				CollectionAssert.AreEqual (actual.ResolvedResourceDirectories.Select (j => j.ItemSpec).OrderBy (j => j),
					expected.ResolvedResourceDirectories.Select (j => j.ItemSpec).OrderBy (j => j));

				// Add a new AAR file to the project
				var aar = new AndroidItem.AndroidAarLibrary ("Jars\\android-crop-1.0.1.aar") {
					WebContent = "https://repo1.maven.org/maven2/com/soundcloud/android/android-crop/1.0.1/android-crop-1.0.1.aar"
				};
				proj.OtherBuildItems.Add (aar);

				b.BuildLogFile = "build3.log";
				Assert.IsTrue (b.Build (proj), "third build should have succeeded.");
				FileAssert.Exists (cacheFile);
				actual = ReadCache (cacheFile);
				Assert.AreEqual (expected.Jars.Length + 1, actual.Jars.Length,
					$"{nameof (expected.Jars)} should have one more item");
				Assert.AreEqual (expected.ResolvedResourceDirectories.Length + 1, actual.ResolvedResourceDirectories.Length,
					$"{nameof (expected.ResolvedResourceDirectories)} should have one more item");
				Assert.AreEqual (expected.ResolvedResourceDirectoryStamps.Length + 1, actual.ResolvedResourceDirectoryStamps.Length,
					$"{nameof (expected.ResolvedResourceDirectoryStamps)} should have one more item");
				foreach (var s in actual.ResolvedResourceDirectoryStamps) {
					FileAssert.Exists (s.ItemSpec);
				}

				// Build with no changes, checking we are skipping targets appropriately
				b.BuildLogFile = "build4.log";
				Assert.IsTrue (b.Build (proj), "fourth build should have succeeded.");
				FileAssert.Exists (cacheFile);
				var targets = new List<string> {
					"_UpdateAndroidResgen",
					"_CompileJava",
					"_CreateBaseApk",
					"_ConvertResourcesCases",
				};
				foreach (var targetName in targets) {
					Assert.IsTrue (b.Output.IsTargetSkipped (targetName), $"`{targetName}` should be skipped!");
				}

				var filesToTouch = new [] {
 					Path.Combine (intermediate, "build.props"),
 					Path.Combine (intermediate, $"{proj.ProjectName}.pdb"),
 				};
				foreach (var file in filesToTouch) {
					FileAssert.Exists (file);
					File.SetLastWriteTimeUtc (file, DateTime.UtcNow);
				}

				b.BuildLogFile = "build5.log";
				Assert.IsTrue (b.Build (proj), "fifth build should have succeeded.");
				b.Output.AssertTargetIsNotSkipped ("_CleanMonoAndroidIntermediateDir");
				b.Output.AssertTargetIsNotSkipped ("_ResolveLibraryProjectImports");
				FileAssert.Exists (cacheFile);
				FileAssert.Exists (stamp);
			}
		}

		ReadLibraryProjectImportsCache ReadCache (string cacheFile)
		{
			var task = new ReadLibraryProjectImportsCache {
				BuildEngine = new MockBuildEngine (new StringWriter ()),
				CacheFile = cacheFile,
			};
			Assert.IsTrue (task.Execute (), $"{nameof (ReadLibraryProjectImportsCache)} should have succeeded.");
			return task;
		}

		[Test]
		[NonParallelizable]
		public void AddNewAndroidResourceOnSecondBuild ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var xml = new AndroidItem.AndroidResource (@"Resources\values\emptyvalues.xml") {
				TextContent = () => "<?xml version=\"1.0\" encoding=\"utf-8\" ?><resources></resources>"
			};

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				var projectFile = Path.Combine (Root, b.ProjectDirectory, proj.ProjectFilePath);
				b.ThrowOnBuildFailure = false;
				Assert.IsTrue (b.Build (proj), "Build should have succeeded.");
				b.Output.AssertTargetIsNotSkipped ("_GenerateAndroidResourceDir");
				proj.OtherBuildItems.Add (xml);
				b.Save (proj, doNotCleanupOnUpdate: true);
				var modified = File.GetLastWriteTimeUtc (Path.Combine (Root, b.ProjectDirectory, "Resources","layout","Main.axml"));
				File.SetLastWriteTimeUtc (Path.Combine (Root, b.ProjectDirectory, "Resources","values", "emptyvalues.xml"), modified);
				Assert.IsTrue (b.Build (proj), "Build should have succeeded.");
				b.Output.AssertTargetIsNotSkipped ("_GenerateAndroidResourceDir");
			}
		}

		[Test]
		[NonParallelizable]
		public void InvalidAndroidResource ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var invalidXml = new AndroidItem.AndroidResource (@"Resources\values\ids.xml") {
				TextContent = () => "<?xml version=\"1.0\" encoding=\"utf-8\" ?><resources><item/></resources>"
			};

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				var projectFile = Path.Combine (Root, b.ProjectDirectory, proj.ProjectFilePath);
				b.ThrowOnBuildFailure = false;
				proj.OtherBuildItems.Add (invalidXml);
				Assert.IsFalse (b.Build (proj), "Build should *not* have succeeded.");

				b.ThrowOnBuildFailure = true;
				proj.OtherBuildItems.Remove (invalidXml);

				//HACK: for random test failure
				b.Save (proj, doNotCleanupOnUpdate: true);
				File.SetLastWriteTimeUtc (projectFile, DateTime.UtcNow.AddMinutes (1));

				Assert.IsTrue (b.Build (proj), "Build should have succeeded.");

				b.ThrowOnBuildFailure = false;
				proj.OtherBuildItems.Add (invalidXml);

				//HACK: for random test failure
				b.Save (proj, doNotCleanupOnUpdate: true);
				File.SetLastWriteTimeUtc (projectFile, DateTime.UtcNow.AddMinutes (1));

				Assert.IsFalse (b.Build (proj), "Build should *not* have succeeded.");
			}
		}

		[Test]
		public void CasingOnJavaLangObject ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var className = "Foo";
			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				Sources = {
					new BuildItem ("Compile", "Foo.cs") {
						TextContent = () => {
							return $"public class {className} : Java.Lang.Object {{ }}";
						}
					},
				}
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");
				className = "fOO";
				proj.Touch ("Foo.cs");
				Assert.IsTrue (b.Build (proj), "second build should have succeeded.");
			}
		}

		[Test]
		public void GenerateJavaStubsAndAssembly ([Values] bool isRelease, [Values] AndroidRuntime runtime)
		{
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			// TODO: NativeAOT build doesn't add android/environment.arm64-v8a.o to file writes
			if (runtime == AndroidRuntime.NativeAOT) {
				Assert.Ignore ("NativeAOT doesn't currently add android/environment.arm64-v8a.o to file writes");
			}

			var targets = new [] {
				"_GenerateJavaStubs",
				"_GeneratePackageManagerJava",
			};
			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);

			string abi = runtime switch {
				AndroidRuntime.MonoVM => "armeabi-v7a",
				AndroidRuntime.CoreCLR => "arm64-v8a",
				AndroidRuntime.NativeAOT => "arm64-v8a",
				_ => throw new NotSupportedException ($"Unsupported runtime '{runtime}'")
			};
			if (runtime == AndroidRuntime.MonoVM) {
				// Using `SetRuntimeIdentifier` would change the intermediate path (by adding the RID component to it) and, thus, the way this test used to work.
				// Keep it as it was.
				proj.SetAndroidSupportedAbis (abi);
			} else {
				proj.SetRuntimeIdentifier (abi);
			}

			proj.OtherBuildItems.Add (new AndroidItem.AndroidEnvironment ("Foo.txt") {
				TextContent = () => "Foo=Bar",
			});
			proj.MainActivity = proj.DefaultMainActivity;
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped!");
				}
				AssertAssemblyFilesInFileWrites (proj, b, abi, runtime);

				// Change C# file and AndroidEvironment file
				proj.MainActivity += Environment.NewLine + "// comment";
				proj.Touch ("MainActivity.cs");
				proj.Touch ("Foo.txt");
				Assert.IsTrue (b.Build (proj), "second build should have succeeded.");
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped!");
				}
				AssertAssemblyFilesInFileWrites (proj, b, abi, runtime);

				// No changes
				Assert.IsTrue (b.Build (proj), "third build should have succeeded.");
				foreach (var target in targets) {
					Assert.IsTrue (b.Output.IsTargetSkipped (target), $"`{target}` should be skipped!");
				}
				AssertAssemblyFilesInFileWrites (proj, b, abi, runtime);
			}
		}

		[Test]
		public void CompileNativeAssemblySourcesSkipsUnchangedFiles ([Values (AndroidRuntime.CoreCLR)] AndroidRuntime runtime)
		{
			if (IgnoreUnsupportedConfiguration (runtime, release: false)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject ();
			proj.SetRuntime (runtime);

			string abi = "arm64-v8a";
			proj.SetRuntimeIdentifier (abi);

			using (var b = CreateApkBuilder ()) {
				b.Verbosity = LoggerVerbosity.Detailed;
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");

				// Modify MainActivity to trigger recompilation of typemap sources
				proj.MainActivity = proj.DefaultMainActivity + Environment.NewLine + "// test comment";
				proj.Touch ("MainActivity.cs");
				Assert.IsTrue (b.Build (proj), "second build should have succeeded.");

				Assert.IsFalse (b.Output.IsTargetSkipped ("_CompileNativeAssemblySources"), "`_CompileNativeAssemblySources` should *not* be skipped!");

				// At least one .ll file should have been skipped as up to date (e.g., environment.arm64-v8a.ll)
				Assert.IsTrue (
					StringAssertEx.ContainsRegex (@"\[LLVM llc\] Skipping.*up to date", b.LastBuildOutput),
					"Expected at least one .ll file to be skipped as up to date"
				);
			}
		}

		readonly string [] ExpectedAssemblyFiles = new [] {
			Path.Combine ("android", "environment.@ABI@.o"),
			Path.Combine ("android", "environment.@ABI@.ll"),
			Path.Combine ("android", "typemaps.@ABI@.o"),
			Path.Combine ("android", "typemaps.@ABI@.ll"),
			Path.Combine ("app_shared_libraries", "@ABI@", "libxamarin-app.so")
		};

		void AssertAssemblyFilesInFileWrites (XamarinAndroidApplicationProject proj, ProjectBuilder b, string abi, AndroidRuntime runtime)
		{
			var intermediate = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath);
			if (runtime == AndroidRuntime.CoreCLR || runtime == AndroidRuntime.NativeAOT) {
				intermediate = Path.Combine (intermediate, MonoAndroidHelper.AbiToRid (abi));
			}

			var lines = File.ReadAllLines (Path.Combine (intermediate, $"{proj.ProjectName}.csproj.FileListAbsolute.txt"));
			foreach (var fileRaw in ExpectedAssemblyFiles) {
				string file = fileRaw.Replace ("@ABI@", abi);
				var path = Path.Combine (intermediate, file);
				CollectionAssert.Contains (lines, path, $"{file} is not in FileWrites!");
				FileAssert.Exists (path);
			}
		}

#pragma warning disable 414
		static object [] AotChecks () => new object [] {
			new object[] {
				/* supportedAbis */   "arm64-v8a",
				/* androidAotMode */  "", // None, Normal, Hybrib, Full
				/* aotAssemblies */   false,
				/* expectedResult */  true,
			},
			new object[] {
				/* supportedAbis */   "arm64-v8a",
				/* androidAotMode */  "Normal", // None, Normal, Hybrid, Full
				/* aotAssemblies */   true,
				/* expectedResult */  true,
			},
			new object[] {
				/* supportedAbis */   "arm64-v8a",
				/* androidAotMode */  "Normal", // None, Normal, Hybrid, Full
				/* aotAssemblies */   false,
				/* expectedResult */  true,
			},
		};
#pragma warning restore 414

		[Test]
		[Category ("AOT")]
		[TestCaseSource (nameof (AotChecks))]
		public void BuildIncrementalAot (string supportedAbis, string androidAotMode, bool aotAssemblies, bool expectedResult)
		{
			// Setup dependencies App A -> Lib B
			var path = Path.Combine ("temp", TestName);

			var libB = new XamarinAndroidLibraryProject {
				ProjectName = "LibraryB",
				IsRelease = true,
				EnableDefaultItems = true,
			};
			libB.Sources.Clear ();
			libB.Sources.Add (new BuildItem.Source ("Foo.cs") {
				TextContent = () => "public class Foo { }",
			});

			var libBBuilder = CreateDllBuilder (Path.Combine (path, libB.ProjectName));
			Assert.IsTrue (libBBuilder.Build(libB), $"{libB.ProjectName} should build");

			var targets = new List<string> {
				"_RemoveRegisterAttribute",
				"_BuildApkEmbed",
			};
			var proj = new XamarinAndroidApplicationProject {
				ProjectName = "AppA",
				IsRelease = true,
				AotAssemblies = aotAssemblies,
				EnableDefaultItems = true,
				Sources = {
					new BuildItem.Source ("Bar.cs") {
						TextContent = () => "public class Bar : Foo { }",
					}
				}
			};
			// Mono-only test
			proj.SetRuntime (AndroidRuntime.MonoVM);
			proj.AddReference (libB);
			if (aotAssemblies) {
				targets.Add ("_AndroidAot");
			}
			proj.SetAndroidSupportedAbis (supportedAbis);
			if (!string.IsNullOrEmpty (androidAotMode))
			    proj.SetProperty ("AndroidAotMode", androidAotMode);
			using (var b = CreateApkBuilder (path)) {
				if (!b.GetSupportedRuntimes ().Any (x => supportedAbis == x.Abi))
					Assert.Ignore ($"Runtime for {supportedAbis} was not available.");

				var apk = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath, $"{proj.PackageName}-Signed.apk");

				b.BuildLogFile = "first.log";
				b.CleanupAfterSuccessfulBuild = false;
				b.CleanupOnDispose = false;
				b.ThrowOnBuildFailure = false;
				Assert.AreEqual (expectedResult, b.Build (proj, doNotCleanupOnUpdate: true), "Build should have {0}.", expectedResult ? "succeeded" : "failed");
				if (!expectedResult)
					return;
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped on first build!");
				}
				AssertNativeLibrariesExist ();

				b.BuildLogFile = "second.log";
				b.CleanupAfterSuccessfulBuild = false;
				b.CleanupOnDispose = false;
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "Second build should have succeeded.");
				foreach (var target in targets) {
					Assert.IsTrue (b.Output.IsTargetSkipped (target), $"`{target}` should be skipped on second build!");
				}
				AssertNativeLibrariesExist ();

				proj.Touch ("MainActivity.cs");

				b.BuildLogFile = "third.log";
				b.CleanupAfterSuccessfulBuild = false;
				b.CleanupOnDispose = false;
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "Third build should have succeeded.");
				foreach (var target in targets) {
					Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should *not* be skipped on third build!");
				}
				AssertNativeLibrariesExist ();

				void AssertNativeLibrariesExist ()
				{
					FileAssert.Exists (apk);
					if (!aotAssemblies)
						return;

					using var zipFile = ZipHelper.OpenZip (apk);
					foreach (var abi in supportedAbis.Split (';')) {
						var path = $"lib/{abi}/libaot-Mono.Android.dll.so";
						var entry = ZipHelper.ReadFileFromZip (zipFile, path);
						Assert.IsNotNull (entry, $"{path} should be in {apk}", abi);
					}
				}
			}
		}

		[Test]
		public void DeterministicBuilds ([Values] bool deterministic, [Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				Deterministic = deterministic,
				//NOTE: so _BuildApkEmbed runs in commercial tests
				EmbedAssembliesIntoApk = true,
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");
				var output = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath, $"{proj.ProjectName}.dll");
				FileAssert.Exists (output);
				string expectedHash = Files.HashFile (output);
				Guid expectedMvid;
				using (var assembly = AssemblyDefinition.ReadAssembly (output)) {
					expectedMvid = assembly.MainModule.Mvid;
				}

				proj.Touch ("MainActivity.cs");
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "second build should have succeeded.");
				FileAssert.Exists (output);
				using (var assembly = AssemblyDefinition.ReadAssembly (output)) {
					if (deterministic) {
						Assert.AreEqual (expectedMvid, assembly.MainModule.Mvid, "Mvid should match");
						Assert.AreEqual (expectedHash, Files.HashFile (output), "hash should match");
					} else {
						Assert.AreNotEqual (expectedMvid, assembly.MainModule.Mvid, "Mvid should *not* match");
						Assert.AreNotEqual (expectedHash, Files.HashFile (output), "hash should *not* match");
					}
				}
			}
		}

		[Test]
		public void DesignTimeBuild ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				b.BuildLogFile = "dtb1.log";
				Assert.IsTrue (b.DesignTimeBuild (proj), "first dtb should have succeeded.");
				var target = "_GenerateResourceDesignerAssembly";
				Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should not have been skipped.");
				var importsTarget = "_ResolveLibraryProjectImports";
				Assert.IsTrue (b.Output.IsTargetSkipped (importsTarget, defaultIfNotUsed: true), $"`{importsTarget}` should have been skipped.");
				// DesignTimeBuild=true lowercased
				var parameters = new [] { "DesignTimeBuild=true" };
				b.BuildLogFile = "compile.log";
				Assert.IsTrue (b.RunTarget (proj, "Compile", doNotCleanupOnUpdate: true, parameters: parameters), "second dtb should have succeeded.");
				Assert.IsTrue (b.Output.IsTargetSkipped (target, defaultIfNotUsed: true), $"`{target}` should have been skipped.");
				Assert.IsTrue (b.Output.IsTargetSkipped (importsTarget, defaultIfNotUsed: true), $"`{importsTarget}` should have been skipped.");
				b.BuildLogFile = "updategeneratedfiles.log";
				Assert.IsTrue (b.RunTarget (proj, "UpdateGeneratedFiles", doNotCleanupOnUpdate: true, parameters: parameters), "UpdateGeneratedFiles should have succeeded.");
				Assert.IsTrue (b.Output.IsTargetSkipped (target, defaultIfNotUsed: true), $"`{target}` should have been skipped.");
				Assert.IsTrue (b.Output.IsTargetSkipped (importsTarget, defaultIfNotUsed: true), $"`{importsTarget}` should have been skipped.");
				b.BuildLogFile = "build.log";
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true, saveProject: false), "full build should have succeeded.");
				Assert.IsFalse (b.Output.IsTargetSkipped (target), $"`{target}` should not have been skipped.");
				Assert.IsFalse (b.Output.IsTargetSkipped (importsTarget), $"`{importsTarget}` should not have been skipped.");
			}
		}

		[Test]
		public void DesignTimeBuildSignAndroidPackage ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			var proj = new XamarinAndroidApplicationProject () {
				IsRelease = isRelease,
				EnableDefaultItems = true,
			};
			proj.SetRuntime (runtime);
			proj.SetProperty ("AndroidUseDesignerAssembly", "true");
			var builder = CreateApkBuilder ();
			var parameters = new [] { "BuildingInsideVisualStudio=true"};
			builder.Verbosity = LoggerVerbosity.Detailed;
			builder.BuildLogFile = "update.log";
			Assert.IsTrue (builder.RunTarget (proj, "Compile", parameters: parameters), $"{proj.ProjectName} should succeed");
			builder.Output.AssertTargetIsNotSkipped ("_GenerateResourceCaseMap", occurrence: 1);
			builder.Output.AssertTargetIsNotSkipped ("_GenerateRtxt");
			builder.Output.AssertTargetIsNotSkipped ("_GenerateResourceDesignerIntermediateClass");
			builder.Output.AssertTargetIsNotSkipped ("_GenerateResourceDesignerAssembly", occurrence: 1);
			parameters = new [] { "BuildingInsideVisualStudio=true" };
			builder.BuildLogFile = "build1.log";
			Assert.IsTrue (builder.RunTarget (proj, "SignAndroidPackage", parameters: parameters), $"{proj.ProjectName} should succeed");
			builder.Output.AssertTargetIsNotSkipped ("_GenerateResourceCaseMap", occurrence: 2);
			builder.Output.AssertTargetIsSkipped ("_GenerateRtxt", defaultIfNotUsed: true);
			builder.Output.AssertTargetIsNotSkipped ("_GenerateResourceDesignerIntermediateClass");
			builder.Output.AssertTargetIsSkipped ("_GenerateResourceDesignerAssembly", defaultIfNotUsed: true);
			builder.BuildLogFile = "build2.log";
			Assert.IsTrue (builder.RunTarget (proj, "SignAndroidPackage", parameters: parameters), $"{proj.ProjectName} should succeed 2");
			builder.Output.AssertTargetIsNotSkipped ("_GenerateResourceCaseMap", occurrence: 3);
			builder.Output.AssertTargetIsSkipped ("_GenerateRtxt", defaultIfNotUsed: true);
			builder.Output.AssertTargetIsSkipped ("_GenerateResourceDesignerIntermediateClass", defaultIfNotUsed: true);
			builder.Output.AssertTargetIsSkipped ("_GenerateResourceDesignerAssembly", defaultIfNotUsed: true);
		}

		[Test]
		public void ChangePackageNamingPolicy ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			proj.Sources.Add (new BuildItem.Source ("Bar.cs") {
				TextContent = () => "namespace Foo { class Bar : Java.Lang.Object { } }"
			});
			proj.SetProperty ("AndroidPackageNamingPolicy", "Lowercase");
			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 = "Lfoo/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}`!");
			}
		}

		[Test]
		public void MissingProjectReference ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			var path = Path.Combine ("temp", TestName);

			var bar = "public class Bar { }";
			var lib = new XamarinAndroidLibraryProject {
				IsRelease = isRelease,
				ProjectName = "MyLibrary",
				Sources = {
					new BuildItem.Source ("Bar.cs") {
						TextContent = () => bar
					},
				}
			};
			lib.SetRuntime (runtime);
			var app = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				ProjectName = "MyApp",
				Sources = {
					new BuildItem.Source ("Foo.cs") {
						TextContent = () => "public class Foo : Bar { }"
					},
				}
			};
			app.SetRuntime (runtime);
			var reference = $"..\\{lib.ProjectName}\\{lib.ProjectName}.csproj";
			app.References.Add (new BuildItem.ProjectReference (reference, lib.ProjectName, lib.ProjectGuid));

			using (var libBuilder = CreateDllBuilder (Path.Combine (path, lib.ProjectName)))
			using (var appBuilder = CreateApkBuilder (Path.Combine (path, app.ProjectName))) {
				libBuilder.ThrowOnBuildFailure =
					appBuilder.ThrowOnBuildFailure = false;

				// Build app before library is built
				Assert.IsFalse (appBuilder.Build (app), "app build should have failed.");
				Assert.IsTrue (StringAssertEx.ContainsText (appBuilder.LastBuildOutput, "warning MSB9008"), "Should receive MSB9008");
				Assert.IsTrue (StringAssertEx.ContainsText (appBuilder.LastBuildOutput, " 1 Warning(s)"), "Should receive 1 Warning");
				Assert.IsTrue (StringAssertEx.ContainsText (appBuilder.LastBuildOutput, "error CS0246"), "Should receive CS0246");
				Assert.IsTrue (StringAssertEx.ContainsText (appBuilder.LastBuildOutput, " 1 Error(s)"), "Should receive 1 Error");

				// Successful build
				Assert.IsTrue (libBuilder.Build (lib), "lib build should have succeeded.");
				Assert.IsTrue (appBuilder.Build (app), "app build should have succeeded.");

				// Create compiler error in library, the app will still be able to build
				bar += "}";
				lib.Touch ("Bar.cs");
				Assert.IsFalse (libBuilder.Build (lib), "lib build should have failed.");
				Assert.IsTrue (appBuilder.Build (app), "app build should have succeeded.");
			}
		}

		[Test]
		public void AaptError ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				Sources = {
					new BuildItem.Source ("TestActivity.cs") {
						TextContent = () => @"using Android.App; [Activity(Theme = ""@style/DoesNotExist"")] class TestActivity : Activity { }"
					}
				}
			};
			proj.SetRuntime (runtime);
			using (var builder = CreateApkBuilder ()) {
				builder.ThrowOnBuildFailure = false;
				Assert.IsFalse (builder.Build (proj), "Build should *not* have succeeded on the first build.");
				Assert.IsFalse (builder.Build (proj), "Build should *not* have succeeded on the second build.");
			}
		}

		[Test]
		public void AndroidResourceChange ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			using (var builder = CreateApkBuilder ()) {
				Assert.IsTrue (builder.Build (proj), "first build should succeed");

				// AndroidResource change
				proj.LayoutMain += $"{Environment.NewLine}<!--comment-->";
				proj.Touch ("Resources\\layout\\Main.axml");
				builder.BuildLogFile = "build2.log";
				Assert.IsTrue (builder.Build (proj), "second build should succeed");

				builder.Output.AssertTargetIsSkipped ("_ResolveLibraryProjectImports");

				// TODO: NativeAOT doesn't skip this target
				if (runtime != AndroidRuntime.NativeAOT) {
					builder.Output.AssertTargetIsSkipped ("_GenerateJavaStubs");
				}
				builder.Output.AssertTargetIsSkipped ("_CompileJava");
				builder.Output.AssertTargetIsSkipped ("_CompileToDalvik");
			}
		}

		[Test]
		public void AndroidAssetChange ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var text = "Foo";
			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);
			proj.OtherBuildItems.Add (new AndroidItem.AndroidAsset ("Assets\\Foo.txt") {
				TextContent = () => text
			});
			using (var b = CreateApkBuilder ()) {
				var apk = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath, $"{proj.PackageName}-Signed.apk");
				Assert.IsTrue (b.Build (proj), "first build should succeed");
				AssertAssetContents (apk);

				// AndroidAsset change
				text = "Bar";
				proj.Touch ("Assets\\Foo.txt");
				Assert.IsTrue (b.Build (proj), "second build should succeed");

				AssertAssetContents (apk);
			}

			void AssertAssetContents (string apk)
			{
				FileAssert.Exists (apk);
				using (var zip = ZipHelper.OpenZip (apk)) {
					var entry = zip.ReadEntry ("assets/Foo.txt");
					Assert.IsNotNull (entry, "Foo.txt should exist in apk!");
					using (var stream = new MemoryStream ())
					using (var reader = new StreamReader (stream)) {
						entry.Extract (stream);
						stream.Position = 0;
						Assert.AreEqual (text, reader.ReadToEnd ());
					}
				}
			}
		}

		[Test]
		public void AndroidAssetMissing ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject {
				IsRelease = isRelease,
				OtherBuildItems = {
					new AndroidItem.AndroidAsset ("Assets\\foo\\bar.txt") {
						TextContent = () => "bar",
					},
				}
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should succeed");

				var apk = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath, $"{proj.PackageName}-Signed.apk");
				FileAssert.Exists (apk);
				using (var zip = ZipHelper.OpenZip (apk)) {
					Assert.IsTrue (zip.ContainsEntry ("assets/foo/bar.txt"), "bar.txt should exist in apk!");
				}

				// Touch $(MSBuildProjectFile)
				var projectFile = Path.Combine (Root, b.ProjectDirectory, proj.ProjectFilePath);
				File.SetLastWriteTimeUtc (projectFile, DateTime.UtcNow.AddMinutes (1));

				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "second build should succeed");
				FileAssert.Exists (apk);
				using (var zip = ZipHelper.OpenZip (apk)) {
					Assert.IsTrue (zip.ContainsEntry ("assets/foo/bar.txt"), "bar.txt should exist in apk!");
				}
			}
		}

		[Test]
		public void ChangeSupportedAbis ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}
			var proj = new XamarinFormsAndroidApplicationProject {
				IsRelease = isRelease,
			};
			proj.SetRuntime (runtime);

			string supportedAbi = runtime switch {
				AndroidRuntime.MonoVM => "armeabi-v7a",
				AndroidRuntime.CoreCLR => "arm64-v8a",
				AndroidRuntime.NativeAOT => "arm64-v8a",
				_ => throw new NotSupportedException ($"Unsupported runtime '{runtime}'")
			};

			string alternativeRid = runtime switch {
				AndroidRuntime.MonoVM => "x86",
				AndroidRuntime.CoreCLR => "x64",
				AndroidRuntime.NativeAOT => "x64",
				_ => throw new NotSupportedException ($"Unsupported runtime '{runtime}'")
			};

			proj.SetAndroidSupportedAbis (supportedAbi);
			using (var b = CreateApkBuilder ()) {
				b.Build (proj);
				b.Build (proj, parameters: new [] { $"{KnownProperties.RuntimeIdentifier}=android-{alternativeRid}" }, doNotCleanupOnUpdate: true);
			}
		}

		[Test]
		public void BuildPropsBreaksConvertResourcesCasesOnSecondBuild ([Values] AndroidRuntime runtime)
		{
			bool isRelease = runtime == AndroidRuntime.NativeAOT;
			if (IgnoreUnsupportedConfiguration (runtime, release: isRelease)) {
				return;
			}

			var proj = new XamarinAndroidApplicationProject () {
				IsRelease = isRelease,
				AndroidResources = {
					new AndroidItem.AndroidResource (() => "Resources\\drawable\\IMALLCAPS.png") {
						BinaryContent = () => XamarinAndroidApplicationProject.icon_binary_mdpi,
					},
					new AndroidItem.AndroidResource ("Resources\\layout\\test.axml") {
						TextContent = () => {
							return "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<ImageView xmlns:android=\"http://schemas.android.com/apk/res/android\" android:src=\"@drawable/IMALLCAPS\" />";
						}
					}
				}
			};
			proj.SetRuntime (runtime);
			using (var b = CreateApkBuilder ()) {
				Assert.IsTrue (b.Build (proj), "first build should have succeeded.");
				var assemblyPath = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath, "UnnamedProject.dll");
				var apkPath = Path.Combine (Root, b.ProjectDirectory, proj.OutputPath, $"{proj.PackageName}-Signed.apk");
				var firstAssemblyWrite = new FileInfo (assemblyPath).LastWriteTime;
				var firstApkWrite = new FileInfo (apkPath).LastWriteTime;

				// Invalidate build.props with newer timestamp, by updating a @(_PropertyCacheItems) property
				proj.SetProperty ("AndroidLinkMode", "SdkOnly");
				Assert.IsTrue (b.Build (proj, doNotCleanupOnUpdate: true), "second build should have succeeded.");
				var secondAssemblyWrite = new FileInfo (assemblyPath).LastWriteTime;
				var secondApkWrite = new FileInfo (apkPath).LastWriteTime;
				Assert.IsTrue (secondAssemblyWrite > firstAssemblyWrite,
					$"Assembly write time was not updated on partially incremental build. Before: {firstAssemblyWrite}. After: {secondAssemblyWrite}.");

				// TODO: NativeAOT fails this with "Apk write time was not updated on partially incremental build. Before: 1/1/1981 1:01:02 AM. After: 1/1/1981 1:01:02 AM."
				if (runtime != AndroidRuntime.NativeAOT) {
					Assert.IsTrue (secondApkWrite > firstApkWrite,
						$"Apk write time was not updated on partially incremental build. Before: {firstApkWrite}. After: {secondApkWrite}.");
				}
			}
		}

	}
}