예제 #1
0
        public void RobustDelete_TemporaryLocked_Deletes_NoException()
        {
            using (var tempFolder = new TemporaryFolder("RobustDelete03"))
            {
                var fileName = Path.Combine(tempFolder.Path, "not_locked.txt");

                FileAssert.DoesNotExist(fileName);

                var worker = new BackgroundWorker();
                worker.DoWork += delegate
                {
                    File.WriteAllText(fileName, @"temp file");
                    using (new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
                    {
                        Thread.Sleep(1700);
                    }
                };
                worker.RunWorkerAsync();

                while (!File.Exists(fileName))
                {
                    Application.DoEvents();
                }

                Assert.DoesNotThrow(() => FileSystemUtils.RobustDelete(fileName));
                FileAssert.DoesNotExist(fileName);
            }
        }
예제 #2
0
        public void Test_delete_target_file()
        {
            CopyDir(sourceDir1, targetDir, NextStorage());
            CopyDir(sourceDir2, targetDir, NextStorage());

            FileAssert.DoesNotExist(dir.CreatePath("target", "file1"));
        }
예제 #3
0
파일: WCFTests.cs 프로젝트: aws/cta
        public void TestCodeBasicHttpNetTCPSupported(string version)
        {
            var solutionPath             = CopySolutionFolderToTemp("PACoreWCFSupport.sln", tempDir);
            TestSolutionAnalysis results = AnalyzeSolution(solutionPath, version);

            var testCaseName = "TC9CodeBasicHttpNetTCPSupported";
            var project      = results.ProjectResults.Where(prop => prop.CsProjectPath.EndsWith(testCaseName + ".csproj")).FirstOrDefault();
            var projectDir   = Directory.GetParent(project.CsProjectPath).FullName;

            var csProjContent = project.CsProjectContent;

            var startupText = File.ReadAllText(Path.Combine(projectDir, "Startup.cs"));
            var programText = File.ReadAllText(Path.Combine(projectDir, "Program.cs"));

            var service = File.ReadAllText(Path.Combine(projectDir, "IEchoService.cs"));

            string corewcfConfigPath = Path.Combine(projectDir, "corewcf_ported.config");

            FileAssert.DoesNotExist(corewcfConfigPath);

            StringAssert.Contains(@"CoreWCF.Primitives", csProjContent);
            StringAssert.Contains(@"CoreWCF.Http", csProjContent);
            StringAssert.Contains(@"CoreWCF.NetTcp", csProjContent);
            StringAssert.Contains(@"Microsoft.AspNetCore", csProjContent);
            StringAssert.DoesNotContain(@"CoreWCF.ConfigurationManager", csProjContent);

            StringAssert.AreEqualIgnoringCase(Regex.Replace(ExpectedOutputConstants.WCFTC9CodeBasedStartupText, @"\r", ""), Regex.Replace(startupText, @"\r", ""));
            StringAssert.AreEqualIgnoringCase(Regex.Replace(ExpectedOutputConstants.WCFTC9CodeBasedProgramText, @"\r", ""), Regex.Replace(programText, @"\r", ""));
            StringAssert.Contains(@"using CoreWCF", service);
        }
예제 #4
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"));
        }
예제 #5
0
        public void TestStoreAtDefaultLocation()
        {
            FileAssert.DoesNotExist(_testLocation);
            FileStream openStream = File.Create(_testLocation);

            openStream.Close();
            StorageSettings.StorageDefaultLocation = _testLocation;
            Environment.CurrentDirectory           = TestContext.CurrentContext.TestDirectory;
            IDictionary <CharacterClass, IEnumerable <IBuild> > builds = new Dictionary <CharacterClass, IEnumerable <IBuild> >();

            builds[CharacterClass.Barbarian] = new List <IBuild>()
            {
                BuildBuilder.BuildDefaultBuild()
            };

            _manager = new StorageManager();
            _manager.StoreAtDefaultLocation(builds);

            FileAssert.Exists(_testLocation);
            string[] lines = File.ReadAllLines(_testLocation);
            Assert.IsTrue(lines.Length > 0);
            Assert.IsFalse(string.IsNullOrEmpty(lines[0]));
            IBuildSerializer serializer = new BuildSerializer();
            IDictionary <CharacterClass, IEnumerable <IBuild> > deserializedBuilds = serializer.Deserialize(_testLocation);

            Assert.AreEqual(1, deserializedBuilds[CharacterClass.Barbarian].Count());
            Assert.AreEqual(BuildBuilder.BuildDefaultBuild(), deserializedBuilds[CharacterClass.Barbarian].First());
        }
 public void WhenBuildLayoutIsDisabled_BuildLayoutIsNotGenerated()
 {
     ProjectConfigData.GenerateBuildLayout = false;
     CreateAddressablePrefab("p1", CreateGroup("Group1"));
     BuildAndExtractLayout();
     FileAssert.DoesNotExist(BuildLayoutGenerationTask.m_LayoutTextFile);
 }
예제 #7
0
        public void DotNetPublish([Values(false, true)] bool isRelease)
        {
            const string runtimeIdentifier = "android.21-arm";
            var          proj = new XASdkProject {
                IsRelease = isRelease
            };

            proj.SetProperty(KnownProperties.RuntimeIdentifier, runtimeIdentifier);
            var dotnet = CreateDotNetBuilder(proj);

            Assert.IsTrue(dotnet.Publish(), "first `dotnet publish` should succeed");

            var publishDirectory = Path.Combine(FullProjectDirectory, proj.OutputPath, runtimeIdentifier, "publish");
            var apk       = Path.Combine(publishDirectory, $"{proj.PackageName}.apk");
            var apkSigned = Path.Combine(publishDirectory, $"{proj.PackageName}-Signed.apk");

            FileAssert.Exists(apk);
            FileAssert.Exists(apkSigned);

            Assert.IsTrue(dotnet.Publish(parameters: new [] { "AndroidPackageFormat=aab" }), $"second `dotnet publish` should succeed");
            var aab       = Path.Combine(publishDirectory, $"{proj.PackageName}.aab");
            var aabSigned = Path.Combine(publishDirectory, $"{proj.PackageName}-Signed.aab");

            FileAssert.DoesNotExist(apk);
            FileAssert.DoesNotExist(apkSigned);
            FileAssert.Exists(aab);
            FileAssert.Exists(aabSigned);
        }
예제 #8
0
 public void DoesNotExistFailsWhenStringExists()
 {
     using (new TestFile("Test1.txt", "TestText1.txt"))
     {
         var ex = Assert.Throws <AssertionException>(() => FileAssert.DoesNotExist("Test1.txt"));
         Assert.That(ex.Message, Is.StringStarting("  Expected: not file exists"));
     }
 }
예제 #9
0
 public void DoesNotExistFailsWhenStringExists()
 {
     using (var tf1 = new TestFile("Test1.txt", "TestText1.txt"))
     {
         var ex = Assert.Throws <AssertionException>(() => FileAssert.DoesNotExist(tf1.File.FullName));
         Assert.That(ex.Message, Does.StartWith("  Expected: not file exists"));
     }
 }
예제 #10
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);
        }
        public void IgnoresZipPackages()
        {
            File.Copy(GetFixtureResouce("Samples", "Acme.Core.1.0.0.0-bugfix.zip"), Path.Combine(rootDir, "Acme.Core.1.0.0.0-bugfix.zip"));
            var downloadPath = Path.Combine(rootDir, "DummyFile.nupkg");

            Assert.Throws <Exception>(() =>
                                      NuGetFileSystemDownloader.DownloadPackage("Acme.Core", new SemanticVersion("1.0.0.0-bugfix"), new Uri(rootDir), downloadPath)
                                      );
            FileAssert.DoesNotExist(downloadPath);
        }
예제 #12
0
        public void FileAssertsTest()
        {
            FileInfo fileInfo1 = new FileInfo(@"D:\development\Text1.txt");
            FileInfo fileInfo2 = new FileInfo(@"D:\development\Text2.txt");

            FileAssert.AreEqual(fileInfo1, fileInfo2);
            FileAssert.AreNotEqual(fileInfo1, new FileInfo(@"D:\Recovery.txt"));
            FileAssert.Exists(fileInfo1);
            FileAssert.DoesNotExist(new FileInfo(@"D:\development\Text3.txt"));
        }
예제 #13
0
        public void TestCleaningIfSomethingExists()
        {
            ObjectCache.Instance.SetObject("testObj", new TestObject {
                Prop1 = "test", Prop2 = 1234
            });

            FileAssert.Exists(actualPath);
            ObjectCache.Instance.Clear();
            FileAssert.DoesNotExist(actualPath);
        }
예제 #14
0
        public void RemoveDocument_deleteDocument_true()
        {
            var sutFielService = new FileService();
            var path           = "C:/temp/testfile.txt";

            File.Create(path).Dispose();
            sutFielService.RemoveDocumentOnSource(path);

            FileAssert.DoesNotExist(path);
        }
예제 #15
0
파일: Tests.cs 프로젝트: zivan92/oom
        public void Test3()
        {
            string[] arr = { "Mein", "dritter", "Test" };

            var id = Utils.SpeichereObj(arr);

            var filename = Utils.BuildFileName(id);

            FileAssert.Exists(filename);
            Utils.DeleteObj(id);
            FileAssert.DoesNotExist(filename);
        }
        public void IsCreatingLogFileWithDateRollingStyleIfFileDoesNotExists()
        {
            // Arrange
            var rollingFileSink = new RollingFileSink(new DirectoryInfo(_logsDirectoryPath), RollingStyle.Date);

            // Assert
            FileAssert.DoesNotExist(_rollingStyleDateLogFilePath);

            rollingFileSink.Write("Message");

            FileAssert.Exists(_rollingStyleDateLogFilePath);
        }
예제 #17
0
        public void TestCreatePdf()
        {
            var fileName = Path.Combine(TestHelper.TempPath, "TextPdf.pdf");

            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }
            FileAssert.DoesNotExist(fileName);

            var st = new StructuredText();

            st.AddHeader1("Überschrift 1");

            st.AddParagraph(TestHelper.Masstext1);

            var code = FileHelper.GetTextResource("code1.txt");

            st.AddCode(code);

            st.AddParagraph(TestHelper.Masstext1);

            st.AddDefinitionListLine("Left1", "Right1");
            st.AddDefinitionListLine("Left2", "Right2");
            st.AddDefinitionListLine("Left3", "Right3");
            st.AddDefinitionListLine("Left4", "Right4");

            st.AddParagraph(TestHelper.Masstext1);

            st.AddTable("Tabelle", TestHelper.GetDataTable());

            st.AddHeader1("Überschrift 2");

            st.AddDefinitionListLine("Left1", "Right1");
            st.AddDefinitionListLine("Left2", "Right2");
            st.AddDefinitionListLine("Left3", "Right3");
            st.AddDefinitionListLine("Left4", "Right4");

            var f = new PdfTextFormatter
            {
                Title          = "Testreport",
                StructuredText = st,
                DateString     = $"Date created: {DateTime.Now:G}",
                Author         = "Testautor"
            };

            f.GetFormattedText();
            f.SaveAsFile(fileName);

            FileAssert.Exists(fileName);

            TestHelper.OpenFile(fileName);
        }
예제 #18
0
        public void PageGenerator_WithIgnoredFiles_IncludesCorrectlyButDoesntCopyIgnoredFileToDestination(string ignoredFilePath)
        {
            var p1 = PageGenerator.NewPage("Include.html", $"<include src=\"{ignoredFilePath}\"/>");
            var p2 = PageGenerator.NewPage(ignoredFilePath, k_TestPage_1);

            PageGenerator.RenderToFile();

            FileAssert.Exists(p1.DestinationHtmlPath);
            FileAssert.DoesNotExist(p2.DestinationHtmlPath);

            Assert.AreEqual(k_TestPage_1, p1.RenderedHtml, "Html differ");
        }
예제 #19
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");
 }
        public void Should_Delete_File_When_Starting_To_Track()
        {
            var existingFile = m_TestDirectory + "/Parent/Existing.txt";

            Directory.CreateDirectory(m_TestDirectory + "/Parent");
            File.WriteAllText(existingFile, "hello world");

            using (var tracker = new TemporaryFileTracker())
            {
                tracker.TrackFile(existingFile);
                FileAssert.DoesNotExist(existingFile);
            }
        }
예제 #21
0
        public void FileService_RemoveDocument_DeletseDocument()
        {
            // Arrange
            var          fileService = new FileService();
            const string path        = "C:/temp/testfile.txt";

            // Act
            File.Create(path).Dispose();
            fileService.RemoveDocumentOnSource(path);

            // Assert
            FileAssert.DoesNotExist(path);
        }
예제 #22
0
        public void AllFiles()
        {
            _extractor.Directories = false;
            _extractor.Pattern     = "*";
            _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.Exists(Path.Combine(_outDir.FullName, "blah2.txt"));
        }
예제 #23
0
        public void BuildAssetBundles_WhenBuildLogProvided_DoesNotCreatePerformanceLogReport()
        {
            IBundleBuildParameters buildParameters = GetBuildParameters();
            IBundleBuildContent    buildContent    = GetBundleContent();
            IBundleBuildResults    results;

            var taskList = DefaultBuildTasks.Create(DefaultBuildTasks.Preset.AssetBundleCompatible);

            ContentPipeline.BuildAssetBundles(buildParameters, buildContent, out results, taskList, new BuildLog());

            string tepBuildLog = buildParameters.GetOutputFilePathForIdentifier("buildlogtep.json");

            FileAssert.DoesNotExist(tepBuildLog);
        }
예제 #24
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);
                }
            }
        }
예제 #25
0
        public void DeleteFiles_fileNamesListAndDirPath_filesDeletedAndReturnSize()
        {
            FileRemover fileRemover = new FileRemover();

            long fSize = fileRemover.DeleteFiles(delFiles, dirPath);

            Assert.Multiple(() =>
            {
                FileAssert.DoesNotExist(Path.Combine(dirPath, file1));
                FileAssert.DoesNotExist(Path.Combine(dirPath, file2));
                FileAssert.DoesNotExist(Path.Combine(dirPath, file3));

                Assert.GreaterOrEqual(fSize, 0);
            });
        }
예제 #26
0
        public void RobustDelete_NotLocked_Deletes_NoException()
        {
            using (var tempFolder = new TemporaryFolder("RobustDelete01"))
            {
                var fileName = Path.Combine(tempFolder.Path, "not_locked.txt");

                FileAssert.DoesNotExist(fileName);

                File.WriteAllText(fileName, @"temp file");
                FileAssert.Exists(fileName);

                Assert.DoesNotThrow(() => FileSystemUtils.RobustDelete(fileName));
                FileAssert.DoesNotExist(fileName);
            }
        }
예제 #27
0
        public void TestStoreMatches()
        {
            string storeFile = _testStoresTarget + "//storetest.json";

            FileAssert.DoesNotExist(storeFile);
            IMatchDataStore      sut            = new MatchDataStore(storeFile);
            IEnumerable <IMatch> matchesToStore = new List <IMatch> {
                new MatchBuilder().WithKills(1).WithRank(1).WithScore(1).WithId(1).WithMode(GameMode.Solo).WithPerspective(GamePerspective.FPP).Build(),
                new MatchBuilder().WithKills(2).WithRank(2).WithScore(2).WithId(2).WithMode(GameMode.Solo).WithPerspective(GamePerspective.FPP).Build(),
                new MatchBuilder().WithKills(3).WithRank(3).WithScore(3).WithId(3).WithMode(GameMode.Solo).WithPerspective(GamePerspective.FPP).Build()
            };

            sut.StoreMatches(matchesToStore);
            FileAssert.Exists(storeFile);
            FileAssert.AreEqual(new FileInfo(TestContext.CurrentContext.TestDirectory + "//TestFiles/Stores/storetest_assert.json"), new FileInfo(storeFile));
        }
예제 #28
0
        public void CanAddAndRemoveSchemaObjectByGenericType()
        {
            var group = Settings.CreateGroup("TestGroup", false, false, false, null);
            var s     = group.AddSchema <CustomTestSchema>();

            Assert.IsNotNull(s);
            string guid;
            long   lfid;

            Assert.IsTrue(AssetDatabase.TryGetGUIDAndLocalFileIdentifier(s, out guid, out lfid));
            var path = AssetDatabase.GUIDToAssetPath(guid);

            FileAssert.Exists(path);
            Assert.IsTrue(group.RemoveSchema <CustomTestSchema>());
            FileAssert.DoesNotExist(path);
        }
        public void Delete_should_remove_entity()
        {
            var testClass = new TestClass {
                Id = 1, Name = "Test name", Description = "Test Description"
            };

            _fileStorage.Store(testClass);

            FileAssert.Exists(_basePath + @"\TestClass\1");

            _fileStorage.Delete(testClass);

            _fileStorage.Load <TestClass>(1).Should().BeNull();

            FileAssert.DoesNotExist(_basePath + @"\TestClass\1");
        }
예제 #30
0
        public void ExecuteWorkDirTest()
        {
            using (var tempDir = TempDirectory.Create())
                using (var runtime = new PowerShellRuntime("ExecuteWorkDirTest"))
                {
                    var outPath = "workDirTest.txt";
                    FileSystem.DeleteFile(outPath);
                    FileAssert.DoesNotExist(outPath);
                    runtime.Execute($"'test' | Out-File workDirTest.txt");
                    FileAssert.Exists(outPath);

                    outPath = Path.Combine(tempDir.TempPath, outPath);
                    FileSystem.DeleteFile(outPath);
                    FileAssert.DoesNotExist(outPath);
                    runtime.Execute($"'test' | Out-File workDirTest.txt", tempDir.TempPath);
                    FileAssert.Exists(outPath);
                }
        }