public void TargetFrameworkDirectories()
{
foreach (var dir in XamarinAndroid.TargetFrameworkDirectories)
{
DirectoryAssert.Exists(dir);
}
}
public void Should_BePossibleTo_SaveAndCompareWithDump_WithOverlengthDumpName_WhenAllElementsSelected()
{
var customForm = new WebForm();
customForm.SetElementsForDump(WebForm.ElementsFilter.AllElements);
var maxElementNameLength = (int)customForm.Dump.GetType().GetMethod("GetMaxNameLengthOfDumpElements", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(customForm.Dump, new object[] { });
var imageExtensioLength = ((ImageFormat)customForm.Dump.GetType().GetProperty("ImageFormat", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(customForm.Dump)).Extension.Length;
var maxLength = (int)customForm.Dump.GetType().GetProperty("MaxFullFileNameLength", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(customForm.Dump);
var pathToDumpLength = PathToDumps.Length;
var dumpName = new string('A', maxLength - pathToDumpLength - maxElementNameLength - imageExtensioLength);
var overlengthDumpName = dumpName + "_BCDE";
var overlengthPathToDump = CleanUpAndGetPathToDump(overlengthDumpName);
var pathToDump = CleanUpAndGetPathToDump(dumpName);
Assert.DoesNotThrow(() => customForm.Dump.Save(overlengthDumpName));
overlengthPathToDump.Refresh();
DirectoryAssert.DoesNotExist(overlengthPathToDump);
pathToDump.Refresh();
DirectoryAssert.Exists(pathToDump);
Assert.That(customForm.Dump.Compare(dumpName), Is.EqualTo(0), "Some elements should be failed to take image, but difference should be around zero");
}
public void CreateExistingFolder()
{
string folder = @"C:\temp";
DirectoryAssert.Exists(folder);
Assert.IsFalse(FileSystemHelper.FolderCreation(folder));
}
public void FindExistingFolder()
{
string folder = @"C:\temp";
DirectoryAssert.Exists(folder);
Assert.IsTrue(FileSystemHelper.FolderVerification(folder));
}
public void FolderExists()
{
var folder = MakeTempFolder();
Assert.That(folder.FullPath, Is.Not.Empty);
DirectoryAssert.Exists(folder.FullPath);
}
public void PatientBothDirs()
{
_extractor.PerPatient = true;
_extractor.Directories = true;
_extractor.Pattern = "$p";
_extractor.Check(new ThrowImmediatelyCheckNotifier());
FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah.txt"));
FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah2.txt"));
_extractor.MovePatient("Sub1", "Rel1", _outDir, new ThrowImmediatelyDataLoadEventListener()
{
ThrowOnWarning = true
}, new GracefulCancellationToken());
_extractor.MovePatient("Sub2", "Rel2", _outDir, new ThrowImmediatelyDataLoadEventListener()
{
ThrowOnWarning = true
}, new GracefulCancellationToken());
FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah.txt"));
FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah2.txt"));
DirectoryAssert.Exists(Path.Combine(_outDir.FullName, "Rel1"));
DirectoryAssert.Exists(Path.Combine(_outDir.FullName, "Rel2"));
DirectoryAssert.DoesNotExist(Path.Combine(_outDir.FullName, "Sub1"));
DirectoryAssert.DoesNotExist(Path.Combine(_outDir.FullName, "Sub2"));
}
public void DirectoryExistsTest()
{
// Test OK.
DirectoryAssert.Exists(new DirectoryInfo(@"M:\work\TestA1"));
// Test OK.
DirectoryAssert.Exists(@"M:\work\TestA1");
}
public void CreateNonExistingFolder()
{
string folder = @"C:\temp\foldertesting";
DirectoryAssert.DoesNotExist(folder);
Assert.IsTrue(FileSystemHelper.FolderCreation(folder));
DirectoryAssert.Exists(folder);
}
public void AfterDeleteFolderDoesNotExist()
{
var folder = MakeTempFolder();
DirectoryAssert.Exists(folder.FullPath);
folder.TryDelete();
DirectoryAssert.DoesNotExist(folder.FullPath);
}
public void ResolveNpmRoot()
{
var actual = _sut.ResolveNpmRoot();
Console.WriteLine(actual);
actual.ShouldNotBeNull();
DirectoryAssert.Exists(actual);
}
public void FindAboveCurrentDirectory()
{
Directory.CreateDirectory("foo");
Directory.CreateDirectory("bar");
Environment.CurrentDirectory = Path.Combine(Environment.CurrentDirectory, "bar");
DirectoryAssert.Exists(Helpers.FindDirectory("foo"));
}
public void DirectoryAssertsTest()
{
DirectoryInfo dirInfo1 = new DirectoryInfo(@"D:\development\Folder1");
DirectoryInfo dirInfo2 = new DirectoryInfo(@"D:\development\Folder2");
DirectoryAssert.AreNotEqual(dirInfo1, dirInfo2);
DirectoryAssert.Exists(dirInfo1);
}
public void Setup()
{
// appears to be run before each test
if (!System.IO.Directory.Exists("TestData"))
{
System.IO.Directory.SetCurrentDirectory("..\\..\\..");
}
DirectoryAssert.Exists("TestData", "Error: Unable to locate TestData folder.");
}
public void CanAccessWorkDirectory()
{
Assert.NotNull(_fixtureContext.WorkDirectory);
#if !PORTABLE
DirectoryAssert.Exists(_fixtureContext.WorkDirectory);
#endif
Assert.That(_setupContext.WorkDirectory, Is.EqualTo(_fixtureContext.WorkDirectory));
Assert.That(TestExecutionContext.CurrentContext.WorkDirectory, Is.EqualTo(_setupContext.WorkDirectory));
}
public void FileChecks()
{
var realFilePath = Assembly.GetExecutingAssembly().Location;
var realFileInfo = new FileInfo(realFilePath);
var realDirectoryPath = Path.GetDirectoryName(realFilePath);
var realDirectoryInfo = new DirectoryInfo(realDirectoryPath);
var nonexistantFilePath = "E:/fake.folder/this.is.fake";
var nonexistantFileInfo = new FileInfo(nonexistantFilePath);
var nonexistantDirectoryPath = Path.GetDirectoryName(nonexistantFilePath);
var nonexistantDirectoryInfo = new DirectoryInfo(nonexistantDirectoryPath);
// Constraint-style asserts:
Assert.That(realFilePath, Does.Exist);
Assert.That(realFileInfo, Does.Exist);
Assert.That(nonexistantFilePath, Does.Not.Exist);
Assert.That(nonexistantFileInfo, Does.Not.Exist);
Assert.That(realDirectoryPath, Does.Exist);
Assert.That(realDirectoryInfo, Does.Exist);
Assert.That(nonexistantDirectoryPath, Does.Not.Exist);
Assert.That(nonexistantDirectoryInfo, Does.Not.Exist);
Assert.That(realDirectoryInfo, Is.Not.Empty);
Assert.That("/folder1/./junk/../folder2", Is.SamePath("/folder1/folder2"));
Assert.That("/folder1/./junk/../folder2/..", Is.Not.SamePath("/folder1/folder2"));
Assert.That("/folder1/./junk/../folder2", Is.SamePath("/FOLDER1/folder2").IgnoreCase);
Assert.That("/folder1/./junk/../folder2", Is.Not.SamePath("/FOLDER1/folder2").RespectCase);
Assert.That("/folder1/./junk/../folder2/./foo", Is.SamePathOrUnder("/folder1/folder2"));
Assert.That("/folder1/./junk/../folder2/./foo", Is.SubPathOf("/folder1"));
// Classic-style asserts:
// see: https://github.com/nunit/docs/wiki/File-Assert
FileAssert.Exists(realFileInfo);
FileAssert.Exists(realFilePath);
FileAssert.DoesNotExist(nonexistantFileInfo);
FileAssert.DoesNotExist(nonexistantFilePath);
DirectoryAssert.Exists(realDirectoryPath);
DirectoryAssert.Exists(realDirectoryInfo);
DirectoryAssert.DoesNotExist(nonexistantDirectoryPath);
DirectoryAssert.DoesNotExist(nonexistantDirectoryInfo);
}
public void TestMountUncDir()
{
var source = (string)_config.source;
var target = (string)_config.target;
_context.CakeContext.MountUncDir(source, target);
DirectoryAssert.Exists(target);
}
public void SilentInstallerTest(MSIInstaller installer)
{
string actualProductName = installer.ProductName.Replace("-oss", "");
// Install
TestContext.Out.WriteLine($"Installing {actualProductName}...");
int installExitCode = installer.Install().ExitCode;
TestContext.Out.WriteLine($" -> installation finished with exit code {installExitCode}");
Assert.That(installExitCode, Is.EqualTo(0), "Product installed successfully (exit code 0)");
// TODO Enable immutable dir check once stack version value is determined
//string immutablePath = Path.Combine(pathsProvider.ElasticImmutableRoot, "Beats", stackVersion, actualProductName);
//TestContext.Out.WriteLine($" -> checking immutable path exists: {immutablePath}");
//DirectoryAssert.Exists(immutablePath, $"Immutable path {immutablePath} exists after installation");
try
{
foreach (string mutableDir in installer.ProductConfig.MutableDirs)
{
string mutablePath = Path.Combine(pathsProvider.ElasticMutableRoot, "Beats", actualProductName, mutableDir);
TestContext.Out.WriteLine($" -> checking mutable path exists: {mutablePath}");
DirectoryAssert.Exists(mutablePath, $"Mutable path {mutablePath} exists after installation");
}
ServiceController service = ServiceController.GetServices().FirstOrDefault(service => service.ServiceName == actualProductName);
TestContext.Out.WriteLine($" -> checking service '{actualProductName}' exists");
Assert.That(service, Is.Not.Null, $"Service named '{actualProductName}' exists");
}
finally
{
// Uninstall
TestContext.Out.WriteLine($"Uninstalling {actualProductName}...");
int uninstallExitCode = installer.Uninstall().ExitCode;
TestContext.Out.WriteLine($" -> uninstall finished with exit code {uninstallExitCode}.");
Assert.That(uninstallExitCode, Is.EqualTo(0), "Product uninstalled successfully (exit code 0)");
// TODO Enable immutable dir check once stack version value is determined
//TestContext.Out.WriteLine($" -> checking immutable path no longer exists: {immutablePath}");
//DirectoryAssert.Exists(immutablePath, $"Immutable path {immutablePath} no longer exists after uninstall");
foreach (string mutableDir in installer.ProductConfig.MutableDirs)
{
string mutablePath = Path.Combine(pathsProvider.ElasticMutableRoot, "Beats", actualProductName, mutableDir);
TestContext.Out.WriteLine($" -> checking mutable path no longer exists: {mutablePath}");
DirectoryAssert.DoesNotExist(mutablePath, $"Mutable path {mutablePath} no longer exists after uninstall");
}
ServiceController service = ServiceController.GetServices().FirstOrDefault(service => service.ServiceName == actualProductName);
TestContext.Out.WriteLine($" -> checking service '{actualProductName}' no longer exists");
Assert.That(service, Is.Null, $"Service named '{actualProductName}' no longer exists");
}
TestContext.Out.WriteLine($"[PASSED] {installer.ProductName} MSI silent install/uninstall");
}
public void TestConstructorCreatesDirectory()
{
if (_cacheDirectory.Exists)
{
_cacheDirectory.Delete();
}
IImageCache cache = new ImageCache();
DirectoryAssert.Exists(_cacheDirectory);
}
public void CreateFolder_Create_True()
{
var sut = new FileService();
var path = "C:/temp/test";
sut.CreateValutaFolderIfNotExists(path);
DirectoryAssert.Exists(path);
Directory.Delete(path);
}
public void Test_delete_subdirectory()
{
dir.CreateDir("sourceDir1", "subdir1");
CopyDir(sourceDir1, targetDir, NextStorage());
DirectoryAssert.Exists(dir.CreatePath("target", "subdir1"));
CopyDir(sourceDir2, targetDir, NextStorage());
DirectoryAssert.DoesNotExist(dir.CreatePath("target", "subdir1"));
}
public async Task RemoveLibrary()
{
var id = new LibraryId("nuget.org", "Newtonsoft.Json", "12.0.2");
DirectoryAssert.Exists(_sut.GetPackageLocation(id));
await _sut.RemoveLibraryAsync(id, CancellationToken.None);
DirectoryAssert.DoesNotExist(Path.GetDirectoryName(_sut.GetPackageLocation(id)));
}
static void AssertDirectory(string path, int expectedChildCount)
{
path = Path.Join(Tmp, path);
DirectoryAssert.Exists(path);
var actualChildCount = Directory.GetFileSystemEntries(path).Length;
Assert.AreEqual(expectedChildCount, actualChildCount);
}
public void Should_BePossibleTo_SaveFormDump_WithDefaultName()
{
var form = new WebForm();
var pathToDump = CleanUpAndGetPathToDump(form.Name.Replace("/", " "));
Assert.DoesNotThrow(() => form.Dump.Save());
pathToDump.Refresh();
DirectoryAssert.Exists(pathToDump);
Assert.Greater(pathToDump.GetFiles().Length, 0, "Dump should contain some files");
}
public void TestLogWriterAdded()
{
if (_log.GetLogWriter(WRITER_NAME) is LogFileWriter writer)
{
DirectoryAssert.Exists(writer.LogDirectory);
}
else
{
Assert.Fail($"LogWriter {WRITER_NAME} is not a LogFileWriter type.");
}
}
public void Should_BePossibleTo_SaveFormDump_WithSubfoldersInName()
{
var form = new WebForm();
var dumpName = $"SubFolder1\\SubFolder2";
var pathToDump = CleanUpAndGetPathToDump(dumpName);
Assert.DoesNotThrow(() => form.Dump.Save(dumpName));
pathToDump.Refresh();
DirectoryAssert.Exists(pathToDump);
Assert.Greater(pathToDump.GetFiles().Length, 0, "Dump should contain some files");
}
private void ConstructorOutputs(FileSystemAdministrativeTools fsat)
{
steamPath = fsat.SteamPath;
steamUserId = fsat.SteamUserId;
steamUserName = fsat.SteamUserName;
System.Diagnostics.Trace.WriteLine(steamPath);
System.Diagnostics.Trace.WriteLine(steamUserId);
System.Diagnostics.Trace.WriteLine(steamUserName);
Assert.IsNotEmpty(steamUserName);
Assert.IsNotEmpty(steamUserId);
DirectoryAssert.Exists(steamPath);
}
public void MultipleTryBuildTest(string folder)
{
var testFolder = Path.Combine(TestDataFolder, folder);
DirectoryAssert.Exists(testFolder);
var logFiles = Directory.GetFiles(testFolder, "*.txt");
var capturedPackets = new List <CapturedPacket>();
foreach (var logFile in logFiles)
{
capturedPackets.AddRange(TcpImporterTestUtils.ReadCapturedPackets(logFile, null));
}
capturedPackets = capturedPackets.OrderBy(x => x.CreatedTimeStamp).ToList();
var handHistories = new List <HandHistory>();
var packetManager = new PPPokerPacketManager();
var handBuilder = new PPPHandBuilder();
var debugPPPImporter = new DebugPPPImporter();
foreach (var capturedPacket in capturedPackets)
{
if (!packetManager.TryParse(capturedPacket, out IList <PPPokerPackage> packages))
{
continue;
}
foreach (var package in packages)
{
if (!PPPImporterStub.IsAllowedPackage(package))
{
continue;
}
package.Timestamp = capturedPacket.CreatedTimeStamp;
debugPPPImporter.LogPackage(capturedPacket, package);
if (handBuilder.TryBuild(package, out HandHistory handHistory))
{
handHistories.Add(handHistory);
LogProvider.Log.Info($"Hand #{handHistory.HandId} has been sent. [{package.ClientPort}]");
}
}
}
WriteHandHistoriesToFile(handHistories);
Assert.IsTrue(handHistories.Count > 0);
}
public void FileService_CreateFolder_SuccessfulCreated()
{
// Arrange
var fileService = new FileService();
const string path = "C:/temp/test";
// Act
fileService.CreateValutaFolderIfNotExists(path);
// Assert
DirectoryAssert.Exists(path);
Directory.Delete(path);
}
public async Task DownloadVizDatasourceFilesAsyncTest()
{
var svc = GetService();
var options = GetOptions();
if (Directory.Exists(options.CurrentValue.DatasourceFilesPath))
{
Directory.Delete(options.CurrentValue.DatasourceFilesPath, true);
}
await svc.DownloadVizDatasourceFilesAsync();
DirectoryAssert.Exists(options.CurrentValue.DatasourceFilesPath);
}
public void DevoCopiarImagens()
{
//string destino = CopiarImagens.Executar();
CopiarImagens.Executar("pastaTeste");
// Verifica se a pasta com o nome informado pelo usuário existe
DirectoryAssert.Exists(@"C:/pastaTeste");
// Verifica se as imagens foram copiadas
DirectoryInfo di = new DirectoryInfo(@"C:/pastaTeste");
Assert.That(di.GetFiles().Length > 0);
}
