public void TestExcelFunctionality_OnSimpleXlsx()
{
var LoadDirectory = CreateLoadDirectoryForTest("TestExcelFunctionality_OnSimpleXlsx");
//clean SetUp anything in the test project folders forloading directory
foreach (FileInfo fileInfo in LoadDirectory.ForLoading.GetFiles())
{
fileInfo.Delete();
}
string targetFile = Path.Combine(LoadDirectory.ForLoading.FullName, "Test.xlsx");
FileInfo fi = new FileInfo(Path.Combine(TestContext.CurrentContext.TestDirectory, "DataLoad", "Engine",
"Resources", "Test.xlsx"));
FileAssert.Exists(fi);
fi.CopyTo(targetFile, true);
TestConversionFor(targetFile, "*.xlsx", 5, LoadDirectory);
}
public void DoubleCache()
{
// Store and flip files in our cache. We should always get
// the most recent file we store for any given URL.
Uri url = new Uri("http://Double.Rainbow.What.Does.It.Mean/");
Assert.IsFalse(cache.IsCached(url));
string file1 = TestData.DogeCoinFlagZip();
string file2 = TestData.ModuleManagerZip();
cache.Store(url, file1);
FileAssert.AreEqual(file1, cache.GetCachedFilename(url));
cache.Store(url, file2);
FileAssert.AreEqual(file2, cache.GetCachedFilename(url));
cache.Store(url, file1);
FileAssert.AreEqual(file1, cache.GetCachedFilename(url));
}
public void EncodeRGBAByScanlines(string file)
{
string fullPath = Path.Combine(TestCase.Folder, file);
string outputPath = Path.Combine(OutputFolder, file);
string expectedPath = Path.Combine(ExpectedFolder, file);
string suffix = "_rgba_scanlines.tif";
string fullOutputPath = outputPath + suffix;
string fullExpectedPath = expectedPath + suffix;
using (Bitmap bmp = new Bitmap(fullPath))
{
using (Tiff tif = Tiff.Open(fullOutputPath, "w"))
{
Assert.IsNotNull(tif);
convertToTiff(bmp, tif, PixelFormat.Format32bppArgb);
}
}
FileAssert.AreEqual(fullExpectedPath, fullOutputPath);
}
public void TestCookbookCodeIsInSync()
{
Regex links = new Regex(@"<sup>(.*)</sup>");
Regex codeStrings = new Regex("@\"([^\"]*)\"", RegexOptions.Singleline);
string cookbookDir = Path.Combine(TestContext.CurrentContext.TestDirectory, "../../../../");
var cookbook = Path.Combine(cookbookDir, "Cookbook.md");
FileAssert.Exists(cookbook);
string content = File.ReadAllText(cookbook);
foreach (Match match in links.Matches(content))
{
var linkIdx = match.Groups[1].Value.IndexOf("./Tests/Cookbook/");
if (linkIdx == -1)
{
continue;
}
var link = match.Groups[1].Value.Substring(linkIdx).TrimEnd(')');
TestContext.Out.WriteLine("Looking for " + link);
var codeFile = Path.Combine(cookbookDir, link);
FileAssert.Exists(codeFile);
string codeContent = File.ReadAllText(codeFile);
foreach (Match codeMatch in codeStrings.Matches(codeContent))
{
if (!content.Contains(codeMatch.Groups[1].Value.Trim()))
{
Assert.Fail($"Cookbook recipe in file '{codeFile}' had code block not in Cookbook.md. Code block was:{codeMatch.Groups[1].Value}");
}
}
}
}
public void ExportSingleTimelineClipFromExportDataTest()
{
string cubeSpecialPath = FindPathInUnitTests("Scene/CubeSpecial.prefab");
GameObject myCube = AddAssetToScene(cubeSpecialPath);
string folderPath = GetRandomFileNamePath(extName: "");
string filePath = null;
var exportData = new Dictionary <GameObject, IExportData>();
PlayableDirector pd = myCube.GetComponent <PlayableDirector>();
if (pd != null)
{
foreach (PlayableBinding output in pd.playableAsset.outputs)
{
AnimationTrack at = output.sourceObject as AnimationTrack;
var atComponent = pd.GetGenericBinding(at) as Component;
Assert.That(atComponent, Is.Not.Null);
var atObject = atComponent.gameObject;
// One file by animation clip
foreach (TimelineClip timeLineClip in at.GetClips())
{
Assert.That(timeLineClip.animationClip, Is.Not.Null);
filePath = $"{folderPath}/{atObject.name}@Recorded.fbx";
exportData[atObject] = ModelExporter.GetExportData(atObject, timeLineClip.animationClip);
break;
}
}
}
Assert.That(filePath, Is.Not.Null);
Assert.That(exportData, Is.Not.Null);
ModelExporter.ExportObjects(filePath, new UnityEngine.Object[1] {
myCube
}, null, exportData);
FileAssert.Exists(filePath);
}
public void AndroidManifestProperties()
{
var packageName = "com.xamarin.singleproject";
var applicationLabel = "My Sweet App";
var versionName = "2.1";
var versionCode = "42";
var proj = new XamarinAndroidApplicationProject();
proj.AndroidManifest = proj.AndroidManifest
.Replace("package=\"${PACKAGENAME}\"", "")
.Replace("android:label=\"${PROJECT_NAME}\"", "")
.Replace("android:versionName=\"1.0\"", "")
.Replace("android:versionCode=\"1\"", "");
if (!Builder.UseDotNet)
{
proj.SetProperty("GenerateApplicationManifest", "true");
}
proj.SetProperty("ApplicationId", packageName);
proj.SetProperty("ApplicationTitle", applicationLabel);
proj.SetProperty("ApplicationVersion", versionName);
proj.SetProperty("AndroidVersionCode", versionCode);
using (var b = CreateApkBuilder()) {
Assert.IsTrue(b.Build(proj), "Build should have succeeded.");
var manifest = b.Output.GetIntermediaryPath("android/AndroidManifest.xml");
FileAssert.Exists(manifest);
using (var stream = File.OpenRead(manifest)) {
var doc = XDocument.Load(stream);
Assert.AreEqual(packageName, doc.Root.Attribute("package")?.Value);
Assert.AreEqual(versionName, doc.Root.Attribute(AndroidAppManifest.AndroidXNamespace + "versionName")?.Value);
Assert.AreEqual(versionCode, doc.Root.Attribute(AndroidAppManifest.AndroidXNamespace + "versionCode")?.Value);
Assert.AreEqual(applicationLabel, doc.Root.Element("application").Attribute(AndroidAppManifest.AndroidXNamespace + "label")?.Value);
}
var apk = b.Output.GetIntermediaryPath($"android/bin/{packageName}.apk");
FileAssert.Exists(apk);
}
}
public void TestCompressorWithContextRows()
{
using (MemoryStream stream = new MemoryStream())
{
jpeg_compress_struct compressor = new jpeg_compress_struct(new jpeg_error_mgr());
compressor.Image_height = 100;
compressor.Image_width = 100;
compressor.In_color_space = J_COLOR_SPACE.JCS_GRAYSCALE;
compressor.Input_components = 1;
compressor.jpeg_set_defaults();
compressor.Dct_method = J_DCT_METHOD.JDCT_IFAST;
compressor.Smoothing_factor = 94;
compressor.jpeg_set_quality(75, true);
compressor.jpeg_simple_progression();
compressor.Density_unit = DensityUnit.Unknown;
compressor.X_density = (short)96;
compressor.Y_density = (short)96;
compressor.jpeg_stdio_dest(stream);
compressor.jpeg_start_compress(true);
byte[][] rowForDecompressor = new byte[1][];
int bytesPerPixel = 1;
while (compressor.Next_scanline < compressor.Image_height)
{
byte[] row = new byte[100 * bytesPerPixel]; // wasteful, but gets you 0 bytes every time - content is immaterial.
rowForDecompressor[0] = row;
compressor.jpeg_write_scanlines(rowForDecompressor, 1);
}
compressor.jpeg_finish_compress();
byte[] bytes = stream.ToArray();
string filename = "TestCompressorWithContextRows.jpg";
File.WriteAllBytes(Tester.MapOutputPath(filename), bytes);
FileAssert.AreEqual(Tester.MapExpectedPath(filename), Tester.MapOutputPath(filename));
}
}
public void DotNetBuild(string runtimeIdentifier, bool isRelease)
{
var abi = MonoAndroidHelper.RuntimeIdentifierToAbi(runtimeIdentifier);
var proj = new XASdkProject {
IsRelease = isRelease
};
proj.OtherBuildItems.Add(new AndroidItem.InputJar("javaclasses.jar")
{
BinaryContent = () => Convert.FromBase64String(InlineData.JavaClassesJarBase64)
});
// TODO: bring back when Xamarin.Android.Bindings.Documentation.targets is working
//proj.OtherBuildItems.Add (new BuildItem ("JavaSourceJar", "javasources.jar") {
// BinaryContent = () => Convert.FromBase64String (InlineData.JavaSourcesJarBase64)
//});
proj.SetProperty(KnownProperties.RuntimeIdentifier, runtimeIdentifier);
var dotnet = CreateDotNetBuilder(proj);
Assert.IsTrue(dotnet.Build(), "`dotnet build` should succeed");
Assert.IsTrue(StringAssertEx.ContainsText(dotnet.LastBuildOutput, " 0 Warning(s)"), "Should have no MSBuild warnings.");
var outputPath = Path.Combine(Root, dotnet.ProjectDirectory, proj.OutputPath, runtimeIdentifier);
var assemblyPath = Path.Combine(outputPath, "UnnamedProject.dll");
FileAssert.Exists(assemblyPath);
using (var assembly = AssemblyDefinition.ReadAssembly(assemblyPath)) {
var typeName = "Com.Xamarin.Android.Test.Msbuildtest.JavaSourceJarTest";
var type = assembly.MainModule.GetType(typeName);
Assert.IsNotNull(type, $"{assemblyPath} should contain {typeName}");
}
var apk = Path.Combine(outputPath, "UnnamedProject.UnnamedProject.apk");
FileAssert.Exists(apk);
using (var zip = ZipHelper.OpenZip(apk)) {
Assert.IsTrue(zip.ContainsEntry($"lib/{abi}/libmonodroid.so"), "libmonodroid.so should exist.");
Assert.IsTrue(zip.ContainsEntry($"lib/{abi}/libmonosgen-2.0.so"), "libmonosgen-2.0.so should exist.");
}
}
public void ApkSet()
{
if (!HasDevices)
{
Assert.Ignore("Skipping Installation. No devices available.");
}
Assert.IsTrue(appBuilder.RunTarget(app, "Install"), "App should have installed.");
var aab = Path.Combine(intermediate, "android", "bin", "UnnamedProject.UnnamedProject.apks");
FileAssert.Exists(aab);
// Expecting: splits/base-arm64_v8a.apk, splits/base-en.apk, splits/base-master.apk, splits/base-xxxhdpi.apk
// This are split up based on: abi, language, base, and dpi
var contents = ListArchiveContents(aab).Where(a => a.EndsWith(".apk", StringComparison.OrdinalIgnoreCase)).ToArray();
Assert.AreEqual(4, contents.Length, "Expecting four APKs!");
using (var stream = new MemoryStream())
using (var apkSet = ZipArchive.Open(aab, FileMode.Open)) {
// We have a zip inside a zip
var baseMaster = apkSet.ReadEntry("splits/base-master.apk");
baseMaster.Extract(stream);
stream.Position = 0;
var uncompressed = new [] { ".dll", ".bar", ".wav" };
using (var baseApk = ZipArchive.Open(stream)) {
foreach (var file in baseApk)
{
foreach (var ext in uncompressed)
{
if (file.FullName.EndsWith(ext, StringComparison.OrdinalIgnoreCase))
{
Assert.AreEqual(CompressionMethod.Store, file.CompressionMethod, $"{file.FullName} should be uncompressed!");
}
}
}
}
}
}
public void IncrementalCleanDuringClean()
{
var path = Path.Combine("temp", TestName);
var proj = new XamarinAndroidApplicationProject()
{
ProjectName = "App1",
IsRelease = true,
};
proj.SetProperty("AndroidUseManagedDesignTimeResourceGenerator", "True");
using (var b = CreateApkBuilder(path)) {
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.");
}
}
public void TestCustomServer(string version)
{
TestSolutionAnalysis results = AnalyzeSolution("CustomServer.sln", tempDir, downloadLocation, version);
var myApp = results.ProjectResults.Where(p => p.CsProjectPath.EndsWith("MyApp.csproj")).FirstOrDefault();
FileAssert.Exists(myApp.CsProjectPath);
var customServer = results.ProjectResults.Where(p => p.CsProjectPath.EndsWith("MyCustomServer.csproj")).FirstOrDefault();
FileAssert.Exists(customServer.CsProjectPath);
//MyApp
var myappProjContent = myApp.CsProjectContent;
var startupText = File.ReadAllText(Path.Combine(myApp.ProjectDirectory, "Startup.cs"));
var programText = File.ReadAllText(Path.Combine(myApp.ProjectDirectory, "Program.cs"));
StringAssert.AreEqualIgnoringCase(ExpectedOutputConstants.CustomServerProgram.NormalizeNewLineChars(), programText.NormalizeNewLineChars());
StringAssert.AreEqualIgnoringCase(ExpectedOutputConstants.CustomServerStartup.NormalizeNewLineChars(), startupText.NormalizeNewLineChars());
//Check for comment on how to implement a custom server here in program
//Check that package has been added:
StringAssert.Contains(@"Microsoft.AspNetCore.Owin", myappProjContent);
StringAssert.Contains(@"Microsoft.AspNetCore.Diagnostics", myappProjContent);
StringAssert.Contains(@"Microsoft.AspNetCore.Server.Kestrel", myappProjContent);
StringAssert.Contains(@"Microsoft.AspNetCore.Hosting", myappProjContent);
//Check that correct version is used
Assert.True(myappProjContent.IndexOf(string.Concat(">", version, "<")) > 0);
//CustomServer
var customProjContent = customServer.CsProjectContent;
var customerServerText = File.ReadAllText(Path.Combine(customServer.ProjectDirectory, "CustomServer.cs"));
var serverFactoryText = File.ReadAllText(Path.Combine(customServer.ProjectDirectory, "ServerFactory.cs"));
//MyCustomerServer very difficult
//Keep their server intact but must implement IServer instead of just IDisposable
//Change their Start class to implement StartAsync instead and change reference to it to startAsync also
//Check that correct version is used
Assert.True(customProjContent.IndexOf(string.Concat(">", version, "<")) > 0);
}
public void SignAndroidPackage_UpdateProperties()
{
string versionCode = "1234",
versionName = "1.2.3.4",
packageName = "com.mycompany.myapp";
var versionCodeElement = MSBuild.NewElement("AndroidVersionCode").WithValue(versionCode);
var versionNameElement = MSBuild.NewElement("AndroidVersionName").WithValue(versionName);
var packageNameElement = MSBuild.NewElement("AndroidPackageName").WithValue(packageName);
var project = MSBuild.NewProject(testDirectory);
var propertyGroup = MSBuild.NewElement("PropertyGroup");
propertyGroup.Add(versionCodeElement);
propertyGroup.Add(versionNameElement);
propertyGroup.Add(packageNameElement);
project.AddFirst(propertyGroup);
var projectFile = Path.Combine(tempDirectory, "test.csproj");
project.Save(projectFile);
MSBuild.Restore(projectFile);
MSBuild.Build(projectFile, "SignAndroidPackage");
versionCodeElement.Value = versionCode = "99";
versionNameElement.Value = versionName = "2.0";
packageNameElement.Value = packageName = "com.mycompany.myapp2";
project.Save(projectFile);
MSBuild.Build(projectFile, "SignAndroidPackage");
var manifestPath = Path.Combine(objDirectory, "AndroidManifest.xml");
FileAssert.Exists(manifestPath);
var ns = AndroidManifest.AndroidNamespace.Namespace;
var manifest = AndroidManifest.Read(manifestPath);
Assert.AreEqual(versionCode, manifest.Document.Attribute(ns + "versionCode")?.Value, "versionCode should match");
Assert.AreEqual(versionName, manifest.Document.Attribute(ns + "versionName")?.Value, "versionName should match");
Assert.AreEqual(packageName, manifest.Document.Attribute("package")?.Value, "package should match");
}
public void DotNetBuildBinding()
{
var proj = new XASdkProject(outputType: "Library");
// Both transform files should be applied
proj.Sources.Add(new AndroidItem.TransformFile("Transforms.xml")
{
TextContent = () =>
@"<metadata>
<attr path=""/api/package[@name='com.xamarin.android.test.msbuildtest']"" name=""managedName"">FooBar</attr>
</metadata>",
});
proj.Sources.Add(new AndroidItem.TransformFile("Transforms\\Metadata.xml")
{
TextContent = () =>
@"<metadata>
<attr path=""/api/package[@managedName='FooBar']"" name=""managedName"">MSBuildTest</attr>
</metadata>",
});
proj.Sources.Add(new AndroidItem.AndroidLibrary("javaclasses.jar")
{
BinaryContent = () => ResourceData.JavaSourceJarTestJar,
});
proj.OtherBuildItems.Add(new BuildItem("JavaSourceJar", "javaclasses-sources.jar")
{
BinaryContent = () => ResourceData.JavaSourceJarTestSourcesJar,
});
var dotnet = CreateDotNetBuilder(proj);
Assert.IsTrue(dotnet.Build(), "`dotnet build` should succeed");
var assemblyPath = Path.Combine(FullProjectDirectory, proj.OutputPath, "UnnamedProject.dll");
FileAssert.Exists(assemblyPath);
using (var assembly = AssemblyDefinition.ReadAssembly(assemblyPath)) {
var typeName = "MSBuildTest.JavaSourceJarTest";
var type = assembly.MainModule.GetType(typeName);
Assert.IsNotNull(type, $"{assemblyPath} should contain {typeName}");
}
}
public void ExtractAll_FileDeleted()
{
using (var zip = ZipArchive.Create(stream)) {
zip.AddEntry("a.txt", "a", encoding);
zip.AddEntry("b/b.txt", "b", encoding);
}
bool changes = ExtractAll(stream);
Assert.IsTrue(changes, "ExtractAll should report changes.");
stream.SetLength(0);
using (var zip = ZipArchive.Open(stream)) {
zip.AddEntry("a.txt", "a", encoding);
}
changes = ExtractAll(stream);
Assert.IsTrue(changes, "ExtractAll should report changes.");
AssertFile("a.txt", "a");
FileAssert.DoesNotExist(Path.Combine(tempDir, "b", "b.txt"));
}
private void TestWebSocketSample(string version)
{
TestSolutionAnalysis results = AnalyzeSolution("WebSocketSample.sln", tempDir, downloadLocation, version);
var sampleClient = results.ProjectResults.Where(p => p.CsProjectPath.EndsWith("SampleClient.csproj")).FirstOrDefault();
FileAssert.Exists(sampleClient.CsProjectPath);
var webSocketServer = results.ProjectResults.Where(p => p.CsProjectPath.EndsWith("WebSocketServer.csproj")).FirstOrDefault();
FileAssert.Exists(webSocketServer.CsProjectPath);
var clientProgramText = File.ReadAllText(Path.Combine(sampleClient.ProjectDirectory, "Program.cs"));
var serverStartupText = File.ReadAllText(Path.Combine(webSocketServer.ProjectDirectory, "Startup.cs"));
var serverProgramText = File.ReadAllText(Path.Combine(webSocketServer.ProjectDirectory, "Program.cs"));
StringAssert.Contains(@"Microsoft.AspNetCore.Builder", serverStartupText);
StringAssert.Contains(@"IApplicationBuilder", serverStartupText);
StringAssert.Contains(@"UseOwin", serverStartupText);
StringAssert.Contains("WebHostBuilder", serverProgramText);
}
public void FileScreenshotConsumer_FileName()
{
consumerBuilder.
WithFileName(@"{screenshot-number:d3} {screenshot-title:* - }{screenshot-pageobjectname}").
Build();
Go.To <BasicControlsPage>();
AtataContext.Current.Log.Screenshot();
AtataContext.Current.Log.Screenshot("Some title");
string folderPath = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
"Logs",
AtataContext.BuildStart.Value.ToString(FileScreenshotConsumer.DefaultDateTimeFormat),
nameof(FileScreenshotConsumer_FileName));
foldersToDelete.Add(folderPath);
FileAssert.Exists(Path.Combine(folderPath, "001 Basic Controls.png"));
FileAssert.Exists(Path.Combine(folderPath, "002 Some title - Basic Controls.png"));
}
public void FileScreenshotConsumer_FilePath()
{
consumerBuilder.
WithFilePath(@"TestLogs\{build-start}\Test {test-name}\{screenshot-number:d2}{screenshot-title: - *}").
Build();
Go.To <BasicControlsPage>();
AtataContext.Current.Log.Screenshot();
AtataContext.Current.Log.Screenshot("Some title");
string folderPath = Path.Combine(
AppDomain.CurrentDomain.BaseDirectory,
"TestLogs",
AtataContext.BuildStart.Value.ToString(FileScreenshotConsumer.DefaultDateTimeFormat),
$"Test {nameof(FileScreenshotConsumer_FilePath)}");
foldersToDelete.Add(folderPath);
FileAssert.Exists(Path.Combine(folderPath, "01.png"));
FileAssert.Exists(Path.Combine(folderPath, "02 - Some title.png"));
}
public void Should_Delete_Existing_File()
{
var existingFile = m_TestDirectory + "/Parent/Existing.txt";
var newFile = m_TestDirectory + "/Parent/File.txt";
Directory.CreateDirectory(m_TestDirectory + "/Parent");
File.Create(existingFile).Dispose();
FileAssert.Exists(existingFile);
using (var tracker = new TemporaryFileTracker())
{
tracker.TrackFile(existingFile, ensureDoesntExist: false);
File.Create(tracker.TrackFile(newFile)).Dispose();
FileAssert.Exists(existingFile);
FileAssert.Exists(newFile);
}
FileAssert.DoesNotExist(existingFile);
FileAssert.DoesNotExist(newFile);
}
[NonParallelizable] // Commonly fails NuGet restore
public void CheckAapt2WarningsDoNotGenerateErrors()
{
//https://github.com/xamarin/xamarin-android/issues/3083
var proj = new XamarinAndroidApplicationProject()
{
IsRelease = true,
TargetFrameworkVersion = Versions.Oreo_27,
UseLatestPlatformSdk = false,
};
proj.PackageReferences.Add(KnownPackages.XamarinForms_2_3_4_231);
proj.PackageReferences.Add(KnownPackages.AndroidSupportV4_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportCompat_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportCoreUI_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportCoreUtils_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportDesign_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportFragment_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportMediaCompat_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportV7AppCompat_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportV7CardView_27_0_2_1);
proj.PackageReferences.Add(KnownPackages.SupportV7MediaRouter_27_0_2_1);
proj.SetProperty(proj.ReleaseProperties, KnownProperties.AndroidCreatePackagePerAbi, true);
proj.SetProperty(proj.ReleaseProperties, KnownProperties.AndroidSupportedAbis, "armeabi-v7a;x86");
using (var b = CreateApkBuilder(Path.Combine("temp", TestName))) {
if (!b.TargetFrameworkExists(proj.TargetFrameworkVersion))
{
Assert.Ignore($"Skipped as {proj.TargetFrameworkVersion} not available.");
}
Assert.IsTrue(b.Build(proj), "first build should have succeeded.");
string intermediateDir = TestEnvironment.IsWindows
? Path.Combine(proj.IntermediateOutputPath, proj.TargetFrameworkAbbreviated) : proj.IntermediateOutputPath;
var packagedResource = Path.Combine(b.Root, b.ProjectDirectory, intermediateDir, "android", "bin", "packaged_resources");
FileAssert.Exists(packagedResource, $"{packagedResource} should have been created.");
var packagedResourcearm = packagedResource + "-armeabi-v7a";
FileAssert.Exists(packagedResourcearm, $"{packagedResourcearm} should have been created.");
var packagedResourcex86 = packagedResource + "-x86";
FileAssert.Exists(packagedResourcex86, $"{packagedResourcex86} should have been created.");
}
}
void CompareFilesIgnoreRuntimeInfoString(string file1, string file2)
{
FileAssert.Exists(file1);
FileAssert.Exists(file2);
var content1 = File.ReadAllText(file1);
var content2 = File.ReadAllText(file2);
// This string is only generated when running on mono, replace with a new line that will be stripped when comparing.
var runtimeVersionRegex = new Regex(@"//\s*Runtime Version:.*");
content1 = runtimeVersionRegex.Replace(content1, Environment.NewLine);
content2 = runtimeVersionRegex.Replace(content2, Environment.NewLine);
using (var s1 = new MemoryStream(Encoding.UTF8.GetBytes(content1)))
using (var s2 = new MemoryStream(Encoding.UTF8.GetBytes(content2))) {
if (!StreamCompare(s1, s2))
{
TestContext.AddTestAttachment(file1, Path.GetFileName(file1));
TestContext.AddTestAttachment(file2, Path.GetFileName(file2));
Assert.Fail($"{file1} and {file2} do not match.");
}
}
}
public void TestExecute_cleans_unfinished_directories_before_starting_the_build()
{
using (var tmpDir = new TmpDir()) {
var partialTask = MockBuildTasks.NoOp("task1")
.WithExecuteAction((sourceDir, outputDir, deps) => {
File.WriteAllText(Path.Combine(outputDir, "foo"), "42");
throw new Exception("Test exception");
});
try {
Builder.Execute(tmpDir.Path, tmpDir.CreateDir("out"), tmpDir.CreateDir(".bud"), partialTask.Object);
} catch (Exception) {
// ignored
}
var fullTask = MockBuildTasks.NoOp("task1")
.WithExecuteAction((sourceDir, outputDir, deps) =>
File.WriteAllText(Path.Combine(outputDir, "bar"), "9001"));
Builder.Execute(tmpDir.Path, tmpDir.CreateDir("out"), tmpDir.CreateDir(".bud"), fullTask.Object);
FileAssert.AreEqual(tmpDir.CreateFile("9001"), tmpDir.CreatePath("out", "bar"));
FileAssert.DoesNotExist(tmpDir.CreatePath("out", "foo"));
}
}
public void UnhandleExceptionExceptionShouldBeLoggedToDiagLogFile(RunnerInfo runnerInfo)
{
AcceptanceTestBase.SetTestEnvironment(this.testEnvironment, runnerInfo);
var diagLogFilePath = Path.Combine(Path.GetTempPath(), $"std_error_log_{Guid.NewGuid()}.txt");
File.Delete(diagLogFilePath);
var assemblyPaths =
this.BuildMultipleAssemblyPath("SimpleTestProject3.dll").Trim('\"');
var arguments = PrepareArguments(assemblyPaths, this.GetTestAdapterPath(), string.Empty, runnerInfo.InIsolationValue);
arguments = string.Concat(arguments, " /testcasefilter:ExitwithUnhandleException");
arguments = string.Concat(arguments, $" /diag:{diagLogFilePath}");
this.InvokeVsTest(arguments);
var errorFirstLine = "Test host standard error line: Unhandled Exception: System.InvalidOperationException: Operation is not valid due to the current state of the object.";
FileAssert.Contains(diagLogFilePath, errorFirstLine);
File.Delete(diagLogFilePath);
}
public void ExecuteWorkDirTest()
{
using (var tempDir = TempDirectory.Create())
using (var runtime = new IronPythonRuntime())
{
var outPath = "workDirTest.txt";
FileSystem.DeleteFile(outPath);
FileAssert.DoesNotExist(outPath);
runtime.Execute(@"f = open('workDirTest.txt', 'w')
f.write('test')
f.close()");
FileAssert.Exists(outPath);
outPath = Path.Combine(tempDir.TempPath, outPath);
FileSystem.DeleteFile(outPath);
FileAssert.DoesNotExist(outPath);
runtime.Execute(@"f = open('workDirTest.txt', 'w')
f.write('test')
f.close()", tempDir.TempPath);
FileAssert.Exists(outPath);
}
}
private void AssertDocFiles(List <string> expectedDocFilesNames, string generatedFilesFolderName)
{
Assert.Multiple(() =>
{
var docFilesPath = OutPutFilePath + "docs\\" + generatedFilesFolderName + "\\";
var generatedDocFileNameList = GetFileNamesList(docFilesPath);
foreach (var expectedFileName in expectedDocFilesNames)
{
Assert.Contains(expectedFileName, generatedDocFileNameList);
var expected = docFilesPath + expectedFileName;
var actual = ActualFilesPath + "docs\\" + generatedFilesFolderName + "\\" + expectedFileName;
FileAssert.Exists(expected, $"{expected} does not exist");
FileAssert.Exists(actual, $"{actual} does not exist");
TestContext.WriteLine(expected + " ---vs--- " + actual);
FileAssert.AreEqual(expected, actual,
"Test failure for " + expectedFileName);
}
});
}
public void StoreRetrieve()
{
Uri url = new Uri("http://example.com/");
string file = Tests.TestData.DogeCoinFlagZip();
// Sanity check, our cache dir is there, right?
Assert.IsTrue(Directory.Exists(cache.GetCachePath()));
// Our URL shouldn't be cached to begin with.
Assert.IsFalse(cache.IsCached(url));
// Store our file.
cache.Store(url, file);
// Now it should be cached.
Assert.IsTrue(cache.IsCached(url));
// Check contents match.
string cached_file = cache.GetCachedFilename(url);
FileAssert.AreEqual(file, cached_file);
}
public void WithoutKey_CreatedExpectedFile()
{
HtmlGenerator generator = new HtmlGenerator();
WordPuzzles.Puzzle.InnerAnacrosticPuzzle puzzle = new WordPuzzles.Puzzle.InnerAnacrosticPuzzle {
PhraseAsString = "max peel"
};
puzzle.AddWordToClues("example");
puzzle.PlaceLetters();
generator.Puzzle = puzzle;
// ReSharper disable StringLiteralTypo
const string TEST_PUZZLE_FILENAME = "test_puzzle_withoutkey.html";
const string EXPECTED_RESULTS_FILENAME = @"data\puzzle_withoutkey.html";
// ReSharper restore StringLiteralTypo
string actualHtml = generator.GenerateHtmlFile(TEST_PUZZLE_FILENAME, false);
Assert.AreEqual(File.ReadAllText(EXPECTED_RESULTS_FILENAME), actualHtml);
FileAssert.AreEqual(EXPECTED_RESULTS_FILENAME, TEST_PUZZLE_FILENAME);
}
public void AreEqualFailsWithStreams()
{
string expectedFile = "Test1.jpg";
string actualFile = "Test2.jpg";
using (TestFile tf1 = new TestFile(expectedFile, "TestImage1.jpg"))
{
using (TestFile tf2 = new TestFile(actualFile, "TestImage2.jpg"))
{
using (FileStream expected = File.OpenRead(expectedFile))
{
using (FileStream actual = File.OpenRead(actualFile))
{
expectedMessage =
string.Format(" Expected Stream length {0} but was {1}." + Environment.NewLine,
new FileInfo(expectedFile).Length, new FileInfo(actualFile).Length);
FileAssert.AreEqual(expected, actual);
}
}
}
}
}
private async Task AssertSinglePageTiffResultsAsync(IEnumerable <ConversionResult> results, Action <string> customAssertions = null)
{
for (int i = 0; i < results.Count(); i++)
{
ConversionResult result = results.ElementAt(i);
Assert.IsTrue(result.IsSuccess);
Assert.AreEqual(1, result.PageCount, "Wrong page count for result");
ConversionSourceDocument resultSourceDocument = result.Sources.ToList()[0];
Assert.IsNotNull(resultSourceDocument.RemoteWorkFile);
Assert.IsNull(resultSourceDocument.Password);
Assert.AreEqual((i + 1).ToString(), resultSourceDocument.Pages, "Wrong source page range for result");
string filename = $"page-{i}.tiff";
await result.RemoteWorkFile.SaveAsync(filename);
FileAssert.IsTiff(filename);
customAssertions?.Invoke(filename);
}
}
public void CanExtractZipFile()
{
var root = Path.Combine(Path.GetDirectoryName(typeof(ZipTests).Assembly.Location), "Exracted");
if (Directory.Exists(root))
{
Directory.Delete(root, recursive: true);
}
File.WriteAllText("foo.txt", "Hello World", encoding: Encoding.ASCII);
File.WriteAllText("foo1.txt", TEXT, encoding: Encoding.ASCII);
using (var zip = ZipArchive.Open("test-archive-write.zip", FileMode.Open)) {
zip.ExtractAll(root);
FileAssert.AreEqual(Path.Combine(root, "file1.txt"), "file1.txt", "file1.txt should have been 1111");
FileAssert.AreEqual(Path.Combine(root, "in", "archive", "path", "ZipTestCopy.exe"), "file1.txt", "ZipTestCopy.exe should have been 1111");
FileAssert.AreEqual(Path.Combine(root, "in", "archive", "path", "ZipTestCopy2.exe"), "file1.txt", "ZipTestCopy2.exe should have been 1111");
FileAssert.AreEqual(Path.Combine(root, "in", "archive", "path", "ZipTestCopy3.exe"), "file1.txt", "ZipTestCopy3.exe should have been 1111");
FileAssert.AreEqual(Path.Combine(root, "invalid", "archive", "path", "ZipTestCopy4.exe"), "file1.txt", "ZipTestCopy4.exe should have been 1111");
FileAssert.AreEqual(Path.Combine(root, "in", "archive", "data", "foo.txt"), "foo.txt", "foo.txt should have been 'Hello World'");
FileAssert.AreEqual(Path.Combine(root, "in", "archive", "foo", "foo.exe"), "file1.txt", "foo.exe should have been 1111");
FileAssert.AreEqual(Path.Combine(root, "in", "archive", "foo", "foo1.txt"), "foo1.txt", $"foo1.txt should have been {TEXT}");
}
}
public static void Test(String tempFolderName, String sourceSubfolderPath)
{
String subfolderName = Path.GetFileName(sourceSubfolderPath);
String tempFolder = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.WorkDirectory, @"Temp\XlsxConverterTesting"));
String tempFolderPath = Path.Combine(tempFolder, subfolderName);
String xlsxFilePath = GetFilePath(Path.Combine(sourceSubfolderPath, "source.xlsx"));
String templateFilePath = GetFilePath(Path.Combine(sourceSubfolderPath, "template.csv"));
String csvFilePath = PrepareCsvFile(Path.Combine(tempFolder, tempFolderName, subfolderName, "result.csv"));
using (StreamWriter streamWriter = new StreamWriter(csvFilePath))
{
CsvWriter csvWriter = new CsvWriter(streamWriter);
MoqDelimitedTextWriter delimitedTextWriter = new MoqDelimitedTextWriter(csvWriter);
XlsxConverter.Convert(xlsxFilePath, delimitedTextWriter);
delimitedTextWriter.Flush();
streamWriter.Flush();
}
FileAssert.AreEqual(csvFilePath, templateFilePath);
}
