コード例 #1
0
        public void Get(IDateTimeProvider timeProvider, ILogger <DataFilePathProvider> logger, IFileSystem fileSystem)
        {
            var settings = Substitute.ForPartsOf <AutoSettings>();

            fileSystem.GetTempDirectoryPath().Returns(Path.GetTempPath());
            var    sut           = new DataFilePathProvider(settings, timeProvider, logger, fileSystem);
            string resultDir     = TestContext.CurrentContext.TestDirectory;
            var    expectedFiles = new[] {
                "collect_deadlock_data_123.xel",
                "collect_long_locks_data_123dfds.xel",
                "ts_sqlprofiler_05_sec_asdv.xel"
            };
            string xEventsDir = CreateTestFiles(timeProvider, expectedFiles);
            var    now        = DateTime.UtcNow.AddHours(1);

            timeProvider.UtcNow.Returns(now);
            settings.EventsDataDirectoryTemplate.Returns(xEventsDir);
            List <string> files = new List <string>();

            foreach (string dir in sut.GetDailyExtEventsDirs())
            {
                resultDir = dir;
                files.AddRange(Directory.EnumerateFiles(dir).Select(Path.GetFileName));
            }
            files.Should().BeEquivalentTo(expectedFiles);
            DirectoryAssert.DoesNotExist(resultDir);
        }
コード例 #2
0
        public void TestFileExists()
        {
            FileInfo file = new FileInfo("111.txt");

            FileAssert.Exists(file);
            DirectoryAssert.DoesNotExist("11");
        }
コード例 #3
0
ファイル: FolderFunctionTester.cs プロジェクト: dudhit/SEBP
        public void FindNonExistingFolder()
        {
            string folder = @"C:\tempp";

            DirectoryAssert.DoesNotExist(folder);
            Assert.IsFalse(FileSystemHelper.FolderVerification(folder));
        }
        public IEnumerator EnableSemanticSegmentation_GeneratesCorrectDataset([Values(true, false)] bool enabled)
        {
            SemanticSegmentationLabeler semanticSegmentationLabeler = null;

            SetupCamera(pc =>
            {
                semanticSegmentationLabeler = new SemanticSegmentationLabeler(CreateSemanticSegmentationLabelConfig());
                pc.AddLabeler(semanticSegmentationLabeler);
            }, enabled);

            string expectedImageFilename = $"segmentation_{Time.frameCount}.png";

            this.AddTestObjectForCleanup(TestHelper.CreateLabeledPlane());
            yield return(null);

            DatasetCapture.ResetSimulation();

            if (enabled)
            {
                var capturesPath = Path.Combine(DatasetCapture.OutputDirectory, "captures_000.json");
                var capturesJson = File.ReadAllText(capturesPath);
                var imagePath    = $"{semanticSegmentationLabeler.semanticSegmentationDirectory}/{expectedImageFilename}";
                StringAssert.Contains(imagePath, capturesJson);
            }
            else
            {
                DirectoryAssert.DoesNotExist(DatasetCapture.OutputDirectory);
            }
        }
コード例 #5
0
        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");
        }
コード例 #6
0
        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"));
        }
コード例 #7
0
        public void AfterDeleteFolderDoesNotExist()
        {
            var folder = MakeTempFolder();

            DirectoryAssert.Exists(folder.FullPath);
            folder.TryDelete();
            DirectoryAssert.DoesNotExist(folder.FullPath);
        }
コード例 #8
0
ファイル: Tests.cs プロジェクト: kolletzki/Cake.UncUtils
        public void TestUnmountUncDir()
        {
            var dir = (string)_config.target;

            _context.CakeContext.UnmountUncDir(dir);

            DirectoryAssert.DoesNotExist(dir);
        }
コード例 #9
0
ファイル: FolderFunctionTester.cs プロジェクト: dudhit/SEBP
        public void CreateNonExistingFolder()
        {
            string folder = @"C:\temp\foldertesting";

            DirectoryAssert.DoesNotExist(folder);
            Assert.IsTrue(FileSystemHelper.FolderCreation(folder));
            DirectoryAssert.Exists(folder);
        }
コード例 #10
0
        public void LongPath()
        {
            var file = NewFile(fileName: "foo".PadRight(MaxFileName, 'N'));
            var task = CreateTask();

            Assert.IsTrue(task.Execute(), "task.Execute() should have succeeded.");
            Assert.AreEqual(1, task.RemovedDirectories.Length, "Changes should have been made.");
            DirectoryAssert.DoesNotExist(tempDirectory);
        }
コード例 #11
0
        public void NoExist()
        {
            Directory.Delete(tempDirectory);
            var task = CreateTask();

            Assert.IsTrue(task.Execute(), "task.Execute() should have succeeded.");
            Assert.AreEqual(0, task.RemovedDirectories.Length, "No changes should have been made.");
            DirectoryAssert.DoesNotExist(tempDirectory);
        }
コード例 #12
0
        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);
        }
コード例 #13
0
        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");
        }
コード例 #14
0
        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"));
        }
コード例 #15
0
        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)));
        }
コード例 #16
0
        public void ReadonlyFile()
        {
            var file = NewFile();

            File.SetAttributes(file, FileAttributes.ReadOnly);
            var task = CreateTask();

            Assert.IsTrue(task.Execute(), "task.Execute() should have succeeded.");
            Assert.AreEqual(1, task.RemovedDirectories.Length, "Changes should have been made.");
            DirectoryAssert.DoesNotExist(tempDirectory);
        }
コード例 #17
0
        public void Should_BeImpossibleTo_SaveFormDump_WithInvalidExtension(string imageExtension)
        {
            var form       = new LiteWebForm(imageExtension);
            var dumpName   = $"Test {imageExtension} extension";
            var pathToDump = CleanUpAndGetPathToDump(dumpName);

            Assert.Throws <NotSupportedException>(() => form.Dump.Save(dumpName));

            pathToDump.Refresh();
            DirectoryAssert.DoesNotExist(pathToDump);
        }
コード例 #18
0
 public void AssertionsMix()
 {
     Assert.True(true);
     Assert.False(false);
     StringAssert.DoesNotContain("DCB", "ABCDEFG");
     CollectionAssert.AllItemsAreNotNull(new List <int>()
     {
         1, 2, 3, 4, 5, 6
     });
     FileAssert.DoesNotExist("somefile.txt");
     DirectoryAssert.DoesNotExist("abcd");
 }
コード例 #19
0
        public void ExtractAll_MacOSFiles()
        {
            using (var zip = ZipArchive.Create(stream)) {
                zip.AddEntry("a/.DS_Store", "a", encoding);
                zip.AddEntry("b/__MACOSX/b.txt", "b", encoding);
                zip.AddEntry("c/__MACOSX", "c", encoding);
            }

            bool changes = ExtractAll(stream);

            Assert.IsFalse(changes, "ExtractAll should *not* report changes.");
            DirectoryAssert.DoesNotExist(tempDir);
        }
コード例 #20
0
        public void LongPath()
        {
            if (LongPathsSupported)
            {
                Assert.Ignore("This environment supports long paths");
            }
            var file = NewFile(fileName: "foo".PadRight(MaxFileName, 'N'));
            var task = CreateTask();

            Assert.IsTrue(task.Execute(), "task.Execute() should have succeeded.");
            Assert.AreEqual(1, task.RemovedDirectories.Length, "Changes should have been made.");
            DirectoryAssert.DoesNotExist(tempDirectory);
            Assert.IsTrue(StringAssertEx.ContainsText(messages.Select(m => m.Message), $"Trying long path: {Files.LongPathPrefix}"), "A long path should be encountered.");
        }
コード例 #21
0
        public void LongPath()
        {
            if (!IsWindows)
            {
                Assert.Ignore("MAX_PATH only applies on Windows");
            }
            var file = NewFile(fileName: "foo".PadRight(250, 'N'));
            var task = CreateTask();

            Assert.IsTrue(task.Execute(), "task.Execute() should have succeeded.");
            Assert.AreEqual(1, task.RemovedDirectories.Length, "Changes should have been made.");
            DirectoryAssert.DoesNotExist(tempDirectory);
            Assert.IsTrue(StringAssertEx.ContainsText(messages.Select(m => m.Message), $"Trying long path: {Files.LongPathPrefix}"), "A long path should be encountered.");
        }
コード例 #22
0
        public void BindingCheckHiddenFiles()
        {
            var binding = new XamarinAndroidBindingProject {
                ProjectName = "Binding",
                IsRelease   = true,
            };

            binding.AndroidClassParser = "class-parse";
            binding.Jars.Add(new AndroidItem.LibraryProjectZip("Jars\\mylibrary.aar")
            {
                WebContentFileNameFromAzure = "mylibrary.aar"
            });
            binding.Jars.Add(new AndroidItem.EmbeddedJar("Jars\\svg-android.jar")
            {
                WebContentFileNameFromAzure = "javaBindingIssue.jar"
            });
            var path = Path.Combine("temp", TestName);

            using (var bindingBuilder = CreateDllBuilder(Path.Combine(path, binding.ProjectName))) {
                Assert.IsTrue(bindingBuilder.Build(binding), "binding build should have succeeded");
                var proj = new XamarinAndroidApplicationProject {
                    ProjectName = "App",
                };
                proj.OtherBuildItems.Add(new BuildItem("ProjectReference", $"..\\{binding.ProjectName}\\{binding.ProjectName}.csproj"));
                proj.AndroidManifest = $@"<?xml version=""1.0"" encoding=""utf-8""?>
<manifest xmlns:android=""http://schemas.android.com/apk/res/android"" xmlns:tools=""http://schemas.android.com/tools"" android:versionCode=""1"" android:versionName=""1.0"" package=""{proj.PackageName}"">
	<uses-sdk />
	<application android:label=""{proj.ProjectName}"" tools:replace=""android:label"">
	</application>
</manifest>";
                using (var b = CreateApkBuilder(Path.Combine(path, proj.ProjectName))) {
                    Assert.IsTrue(b.Build(proj), "Build should have succeeded.");
                    var assemblyMap = b.Output.GetIntermediaryPath(Path.Combine("lp", "map.cache"));
                    FileAssert.Exists(assemblyMap);
                    var libraryProjects      = Path.Combine(Root, b.ProjectDirectory, proj.IntermediateOutputPath, "lp");
                    var assemblyIdentityMap  = b.Output.GetAssemblyMapCache();
                    var assemblyIdentityName = Builder.UseDotNet ? "mylibrary.aar" : $"{binding.ProjectName}.dll";
                    var assemblyIdentity     = assemblyIdentityMap.IndexOf(assemblyIdentityName).ToString();
                    var dsStorePath          = Path.Combine(libraryProjects, assemblyIdentity, "jl");
                    DirectoryAssert.Exists(dsStorePath);
                    FileAssert.DoesNotExist(Path.Combine(dsStorePath, ".DS_Store"));
                    DirectoryAssert.DoesNotExist(Path.Combine(dsStorePath, "_MACOSX"));
                    var svgJar = Builder.UseDotNet ?
                                 Path.Combine(libraryProjects, assemblyIdentityMap.IndexOf($"{binding.ProjectName}.aar").ToString(), "jl", "libs", "FD575F2BC294C4A9.jar") :
                                 Path.Combine(dsStorePath, "svg-android.jar");
                    FileAssert.Exists(svgJar);
                }
            }
        }
コード例 #23
0
        public void OneFile()
        {
            _extractor.Directories = false;
            _extractor.Pattern     = "blah.*";
            _extractor.Check(new ThrowImmediatelyCheckNotifier());

            FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah.txt"));
            FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah2.txt"));

            _extractor.MoveAll(_outDir, new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());

            FileAssert.Exists(Path.Combine(_outDir.FullName, "blah.txt"));
            FileAssert.DoesNotExist(Path.Combine(_outDir.FullName, "blah2.txt"));
            DirectoryAssert.DoesNotExist(Path.Combine(_outDir.FullName, "Sub1"));
            DirectoryAssert.DoesNotExist(Path.Combine(_outDir.FullName, "Sub2"));
        }
コード例 #24
0
        public void ValidateScriptDomainAppBase()
        {
            _sut.DisplayName         = GetType().Assembly.Location;
            _sut.ReadAssemblyContent = () => File.ReadAllBytes(GetType().Assembly.Location);
            _sut.Configuration       = new AssemblyScriptConfiguration(typeof(StepWithSubDomain).Name, nameof(StepWithSubDomain.ShowAppBase));

            _sut.Execute(new DbCommandProxy(_command.Object), _variables, _log.Object);

            Assert.AreEqual(2, _executedScripts.Count);

            var assemblyFileName = _executedScripts[0];

            FileAssert.DoesNotExist(assemblyFileName);
            Assert.AreEqual(Path.GetFileName(assemblyFileName), Path.GetFileName(GetType().Assembly.Location));

            var appBase = _executedScripts[1];

            DirectoryAssert.DoesNotExist(appBase);
            Assert.AreEqual(appBase, Path.GetDirectoryName(assemblyFileName));
        }
コード例 #25
0
        public void UnlinkSourceSdkProject()
        {
            // Arrange
            var dllPath = Path.Combine(Constants.TestBasePath, @"Package.Sdk\1.0.0\lib\netstandard2.0\Package.Sdk.dll");

            Directory.CreateDirectory(Path.GetDirectoryName(dllPath));
            File.WriteAllText(dllPath, "");
            var csprojPath = Path.Combine(Constants.TestSoltuionSrc, @"Package.Sdk\Package.Sdk.csproj");
            var console    = new NuGet.CommandLine.Console();
            var linkArgs   = new UnlinkArgs
            {
                CurrentDirectory = Path.GetDirectoryName(csprojPath),
                Console          = console,
            };
            var runner = new UnlinkCommandRunner(linkArgs);

            // Act
            runner.Unlink();

            // Assert
            DirectoryAssert.DoesNotExist(Path.Combine(Constants.TestBasePath, LinkCommandRunner.BasePath, @"Package.Sdk\1.0.0"));
        }
        public void Should_Create_And_Delete_Directory()
        {
            using (var trackerA = new TemporaryFileTracker())
            {
                trackerA.CreateDirectory(m_TestDirectory + "/Parent/Child");
                using (var trackerB = new TemporaryFileTracker())
                {
                    File.Create(trackerB.TrackFile(m_TestDirectory + "/Parent/Child/File.txt")).Dispose();
                    File.Create(trackerB.TrackFile(m_TestDirectory + "/Parent/File.txt")).Dispose();

                    DirectoryAssert.Exists(m_TestDirectory + "/Parent/Child");
                    FileAssert.Exists(m_TestDirectory + "/Parent/Child/File.txt");
                    FileAssert.Exists(m_TestDirectory + "/Parent/File.txt");
                }

                FileAssert.DoesNotExist(m_TestDirectory + "/Parent/Child/File.txt");
                FileAssert.DoesNotExist(m_TestDirectory + "/Parent/File.txt");
                DirectoryAssert.Exists(m_TestDirectory + "/Parent/Child");
            }

            DirectoryAssert.DoesNotExist(m_TestDirectory + "/Parent/Child");
            DirectoryAssert.DoesNotExist(m_TestDirectory + "/Parent");
            DirectoryAssert.Exists(m_TestDirectory);
        }
コード例 #27
0
 public void DoesNotExistPassesWhenStringDoesNotExist()
 {
     DirectoryAssert.DoesNotExist(BAD_DIRECTORY);
 }
コード例 #28
0
 public void DoesNotExistPassesWhenDirectoryInfoDoesNotExist()
 {
     DirectoryAssert.DoesNotExist(new DirectoryInfo(BAD_DIRECTORY));
 }
コード例 #29
0
        public void DoesNotExistFailsWhenStringIsNull()
        {
            var ex = Assert.Throws <ArgumentNullException>(() => DirectoryAssert.DoesNotExist((string)null));

            Assert.That(ex.Message, Does.StartWith("The actual value must be a non-null string or DirectoryInfo"));
        }
コード例 #30
0
        public void DoesNotExistFailsWhenStringIsEmpty()
        {
            var ex = Assert.Throws <ArgumentException>(() => DirectoryAssert.DoesNotExist(string.Empty));

            Assert.That(ex.Message, Does.StartWith("The actual value cannot be an empty string"));
        }