Merge pull request #11 from IntelliTect/updateListingManager

KennethWhite · web-flow · commit a591ff3e5475 · 2022-05-17T09:25:55.000-07:00
Update listing manager
diff --git a/ListingManager.Tests/ListingManager.Tests.csproj b/ListingManager.Tests/ListingManager.Tests.csproj
@@ -4,13 +4,19 @@
         <TargetFramework>netcoreapp3.1</TargetFramework>
 
         <IsPackable>false</IsPackable>
+
+        <LangVersion>10</LangVersion>
+
+        <Nullable>enable</Nullable>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="IntelliTect.TestTools.Console" Version="1.0.0-CI-20181030-214503" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
         <PackageReference Include="MSTest.TestAdapter" Version="1.4.0" />
         <PackageReference Include="MSTest.TestFramework" Version="1.4.0" />
+        <PackageReference Include="Polly" Version="7.2.3" />
+        <PackageReference Include="xunit" Version="2.4.1" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/ListingManager.Tests/ListingManagerTests.cs b/ListingManager.Tests/ListingManagerTests.cs
diff --git a/ListingManager.Tests/TempFileTestBase.cs b/ListingManager.Tests/TempFileTestBase.cs
@@ -0,0 +1,147 @@
+﻿using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Polly;
+using Xunit.Sdk;
+
+namespace ListingManager.Tests
+{
+    public abstract class TempFileTestBase : IDisposable
+    {
+         private readonly Lazy<DirectoryInfo> _WorkingDirectory = new(() =>
+        {
+            DirectoryInfo working = new(Path.Combine(Path.GetTempPath(),
+                typeof(TempFileTestBase).Assembly.GetName().Name!,
+                Path.GetRandomFileName()));
+
+            if (working.Exists)
+            {
+                working.Delete(recursive: true);
+            }
+
+            working.Create();
+            return working;
+        }, LazyThreadSafetyMode.ExecutionAndPublication);
+
+        private readonly List<FileInfo> _TempFiles = new();
+        private readonly List<DirectoryInfo> _TempDirectories = new();
+        protected DirectoryInfo TempDirectory => _WorkingDirectory.Value;
+        private bool _Disposed;
+
+
+        private FileInfo CreateTempFileWithContent(DirectoryInfo? parentDirectory, string? name = null, byte[]? fileContents = null, string? extension = null)
+        {
+            var tempFile = new FileInfo(GetPath(parentDirectory, name, extension, false));
+
+            using (FileStream stream = tempFile.OpenWrite())
+            {
+                if (fileContents != null)
+                {
+                    stream.Write(fileContents, 0, fileContents.Length);
+                }
+            }
+
+            _TempFiles.Add(tempFile);
+            return tempFile;
+        }
+
+        protected FileInfo CreateTempFile(DirectoryInfo? parentDirectory = null, string? name = null, string? contents = null,
+            string? extension = null)
+        {
+            return CreateTempFileWithContent(parentDirectory, name, contents is null ? null : Encoding.ASCII.GetBytes(contents), extension);
+        }
+
+        public DirectoryInfo CreateTempDirectory(DirectoryInfo? parentDirectory = null, string? name = null)
+        {
+            var tempDir = new DirectoryInfo(GetPath(parentDirectory, name, null, false));
+            tempDir.Create();
+            _TempDirectories.Add(tempDir);
+            return tempDir;
+        }
+
+        protected void AddTempDirectory(DirectoryInfo directory)
+        {
+            _ = directory ?? throw new ArgumentNullException(nameof(directory));
+            _TempDirectories.Add(directory);
+        }
+
+        protected void AddTempFile(FileInfo file)
+        {
+            _ = file ?? throw new ArgumentNullException(nameof(file));
+            _TempFiles.Add(file);
+        }
+
+
+        private string GetPath(DirectoryInfo? parentDirectory, string? name, string? extension, bool randomPrefix)
+        {
+            DirectoryInfo directory = parentDirectory ?? _WorkingDirectory.Value;
+
+            string prefix = randomPrefix && !string.IsNullOrEmpty(name)
+                ? Path.GetFileNameWithoutExtension(Path.GetRandomFileName())
+                : "";
+
+            string fileName = prefix + (name ?? Path.GetRandomFileName());
+
+            if (!string.IsNullOrEmpty(extension))
+            {
+                fileName = Path.ChangeExtension(fileName, extension);
+            }
+
+            return Path.Combine(directory.FullName, fileName);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_Disposed || !disposing)
+            {
+                return;
+            }
+
+            _Disposed = true;
+
+            ExceptionAggregator aggregator = new();
+
+            IEnumerable<FileSystemInfo> items = _TempFiles
+                .Cast<FileSystemInfo>()
+                .Concat(_TempDirectories)
+                .Concat(_WorkingDirectory.IsValueCreated ? new[] { _WorkingDirectory.Value } : Enumerable.Empty<DirectoryInfo>());
+
+            foreach (FileSystemInfo fsi in items)
+            {
+                fsi.Refresh();
+                if (!fsi.Exists) continue;
+
+                Action? action = fsi switch
+                {
+                    FileInfo file => () => file.Delete(),
+                    DirectoryInfo dir => () => dir.Delete(recursive: true),
+                    _ => null,
+                };
+
+                if (action is null) continue;
+
+                aggregator.Run(() =>
+                {
+                    Policy
+                        .Handle<Exception>()
+                        .WaitAndRetry(retryCount: 100, _ => TimeSpan.FromMilliseconds(10))
+                        .Execute(action);
+                });
+            }
+
+            if (aggregator.HasExceptions)
+            {
+                throw aggregator.ToException();
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}
diff --git a/ListingManager/FileManager.cs b/ListingManager/FileManager.cs
@@ -1,21 +1,39 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 
 namespace ListingManager
 {
+    /// <summary>
+    /// A path utility class
+    /// </summary>
     public static class FileManager
     {
-        public static IEnumerable<string> GetAllFilesAtPath(string pathToSearch, bool recursive = false, string searchPattern = "*")
+        /// <summary>
+        /// Retrieves all files in the target directory <paramref name="pathToSearch"/> that match the specified pattern <paramref name="searchPattern"/>
+        /// </summary>
+        /// <param name="pathToSearch">The target directory</param>
+        /// <param name="recursive">Whether to recursively descend from the target directory</param>
+        /// <param name="searchPattern">The search string to match against the names of files in the target path</param>
+        /// <returns></returns>
+        public static IEnumerable<string> GetAllFilesAtPath(string pathToSearch, bool recursive = false,
+            string searchPattern = "*")
         {
             return Directory.EnumerateFiles(pathToSearch,
                 searchPattern,
                 recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
         }
 
+        /// <summary>
+        /// Parses the numerical value of the chapter number from the specified path <paramref name="pathToChapter"/>.
+        /// </summary>
+        /// <param name="pathToChapter">The target chapter</param>
+        /// <returns></returns>
         public static int GetFolderChapterNumber(string pathToChapter)
         {
             string chapterText = "Chapter";
-            int startOfChapterNumber = pathToChapter.IndexOf(chapterText) + chapterText.Length;
+            int startOfChapterNumber =
+                pathToChapter.IndexOf(chapterText, StringComparison.Ordinal) + chapterText.Length;
 
             return int.Parse(pathToChapter.Substring(startOfChapterNumber, 2));
         }
diff --git a/ListingManager/ListingManager.cs b/ListingManager/ListingManager.cs
@@ -8,6 +8,9 @@
 
 namespace ListingManager
 {
+    /// <summary>
+    /// A utility class providing means to rename listings, namespaces, and corresponding unit tests.
+    /// </summary>
     public static class ListingManager
     {
         public static IEnumerable<string> GetAllExtraListings(string pathToStartFrom)
@@ -21,7 +24,7 @@ public static IEnumerable<string> GetAllExtraListings(string pathToStartFrom)
             }
         }
 
-        private static bool TryGetListing(string listingPath, out ListingInformation listingData)
+        private static bool TryGetListing(string listingPath, out ListingInformation? listingData)
         {
             listingData = null;
 
@@ -39,10 +42,19 @@ private static bool TryGetListing(string listingPath, out ListingInformation lis
             return true;
         }
 
+        /// <summary>
+        /// Updates the namespace, file names, and corresponding test file of the target listing. This has a cascading
+        /// effect, resulting in the renaming of subsequent listings in the same chapter.
+        /// </summary>
+        /// <param name="pathToChapter">Path to the target chapter</param>
+        /// <param name="verbose">When true, enables verbose console output</param>
+        /// <param name="preview">When true, leaves files in place and only print console output</param>
+        /// <param name="byFolder">Changes a listing's chapter based on the chapter number in the chapter's path</param>
+        /// <param name="chapterOnly">Changes only the chapter of the listing, leaving the listing number unchanged. Use with <paramref name="byFolder"/></param>
         public static void UpdateChapterListingNumbers(string pathToChapter,
-            bool verboseMode = false, bool preview = false, bool byFolder = false, bool chapterOnly = false)
+            bool verbose = false, bool preview = false, bool byFolder = false, bool chapterOnly = false)
         {
-            var listingData = new List<ListingInformation>();
+            var listingData = new List<ListingInformation?>();
 
 
             List<string> allListings = FileManager.GetAllFilesAtPath(pathToChapter)
@@ -59,8 +71,9 @@ public static void UpdateChapterListingNumbers(string pathToChapter,
                 string cur = allListings[i];
 
                 var curListingData = listingData[i];
+                
 
-                if (!chapterOnly && !byFolder && listingNumber == curListingData.ListingNumber) { continue; } //default
+                if (curListingData is null || !chapterOnly && !byFolder && listingNumber == curListingData.ListingNumber) { continue; } //default
 
                 string completeListingNumber = listingNumber + ""; //default
                 int listingChapterNumber = curListingData.ChapterNumber; //default
@@ -78,14 +91,14 @@ public static void UpdateChapterListingNumbers(string pathToChapter,
 
                 UpdateListingNamespace(cur, listingChapterNumber,
                     completeListingNumber,
-                    curListingData.ListingDescription, verboseMode, preview);
+                    curListingData.ListingDescription, verbose, preview);
 
                 if (GetPathToAccompanyingUnitTest(cur, out string pathToTest))
                 {
                     Console.Write("Updating test. ");
                     UpdateListingNamespace(pathToTest, listingChapterNumber,
                         completeListingNumber,
-                        curListingData.ListingDescription, verboseMode, preview);
+                        string.IsNullOrEmpty(curListingData.ListingDescription) ? "Tests" : curListingData.ListingDescription + ".Tests", verbose, preview);
                 }
 
             }
@@ -96,14 +109,22 @@ public static bool IsExtraListing(string path,
         {
             Regex fileNameRegex = new Regex(regexNamespace);
 
-            string directoryNameFull = Path.GetDirectoryName(path);
-
+            string directoryNameFull = Path.GetDirectoryName(path) ?? string.Empty;
             string directoryName = Path.GetFileName(directoryNameFull);
 
             return fileNameRegex.IsMatch(path) && !directoryName.Contains(".Tests");
         }
 
-        public static void UpdateListingNamespace(string path, int chapterNumber, string listingNumber,
+        /// <summary>
+        /// Updates the namespace and file name of the listing at <paramref name="path"/>
+        /// </summary>
+        /// <param name="path">The path to the target listing</param>
+        /// <param name="chapterNumber">The chapter the listing belongs to</param>
+        /// <param name="listingNumber">The updated listing number</param>
+        /// <param name="listingData">The name of the listing to be included in the namespace/path</param>
+        /// <param name="verbose">When true, enables verbose console output</param>
+        /// <param name="preview">When true, leaves files in place and only print console output</param>
+        private static void UpdateListingNamespace(string path, int chapterNumber, string listingNumber,
             string listingData, bool verbose = false, bool preview = false)
         {
             string paddedChapterNumber = chapterNumber.ToString("00");
@@ -127,7 +148,7 @@ public static void UpdateListingNamespace(string path, int chapterNumber, string
             string newFileName = string.Format(newFileNameTemplate,
                 paddedChapterNumber,
                 paddedListingNumber,
-                string.IsNullOrWhiteSpace(listingData) ? "" : $".{listingData}");
+                string.IsNullOrWhiteSpace(listingData) || string.IsNullOrEmpty(listingData) ? "" : $".{listingData}");
 
             if (verbose)
             {
@@ -137,19 +158,19 @@ public static void UpdateListingNamespace(string path, int chapterNumber, string
             if (!preview) UpdateNamespaceOfPath(path, newNamespace, newFileName);
         }
 
-        public static bool UpdateNamespaceOfPath(string path, string newNamespace, string newFileName = "")
+        private static void UpdateNamespaceOfPath(string path, string newNamespace, string newFileName = "")
         {
             if (Path.GetExtension(path) != ".cs")
             {
-                return false;
+                return;
             }
 
             // read file into memory
             string[] allLinesInFile = File.ReadAllLines(path);
 
             File.Delete(path);
 
-            string targetPath = Path.Combine(Path.GetDirectoryName(path), newFileName) ?? path;
+            string targetPath = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty, newFileName) ?? path;
 
             using (TextWriter textWriter = new StreamWriter(targetPath, true))
             {
@@ -165,8 +186,6 @@ public static bool UpdateNamespaceOfPath(string path, string newNamespace, strin
                     }
                 }
             }
-
-            return true;
         }
 
         public static bool GetPathToAccompanyingUnitTest(string listingPath, out string pathToTest)
@@ -200,7 +219,7 @@ public static bool GetPathToAccompanyingUnitTest(string listingPath, out string
             return false;
         }
 
-        public static string GetTestLayout(string chapterNumber, string listingNumber)
+        private static string GetTestLayout(string chapterNumber, string listingNumber)
         {
             return string.Format(TestHeaderLayout,
                        chapterNumber.PadLeft(2, '0'),
@@ -226,7 +245,7 @@ public void UnitTest1()
     }
 }";
 
-        public static IEnumerable<string> GetAllMissingUnitTests(string pathToChapter)
+        private static IEnumerable<string> GetAllMissingUnitTests(string pathToChapter)
         {
             foreach (string file in FileManager.GetAllFilesAtPath(pathToChapter).OrderBy(x => x))
             {
@@ -237,7 +256,7 @@ public static IEnumerable<string> GetAllMissingUnitTests(string pathToChapter)
             }
         }
 
-        public static ICollection<string> GenerateUnitTests(string pathToChapter, Func<string, bool> action = null,
+        public static ICollection<string> GenerateUnitTests(string pathToChapter, Func<string, bool>? action = null,
             bool verbose = false)
         {
             var toReturn = new List<string>();
@@ -267,7 +286,7 @@ public static ICollection<string> GenerateUnitTests(string pathToChapter, Func<s
             return toReturn;
         }
 
-        public static bool GenerateUnitTest(string pathToTest)
+        private static bool GenerateUnitTest(string pathToTest)
         {
             if (File.Exists(pathToTest))
             {
diff --git a/ListingManager/ListingManager.csproj b/ListingManager/ListingManager.csproj
@@ -10,10 +10,13 @@
         <PackageId>IntelliTect.EssentialCSharp.ListingManager</PackageId>
         <Description>Tool used to expose useful functionality to IntelliTect/EssentialCSharp collaborators</Description>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <LangVersion>10</LangVersion>
+        <Nullable>enable</Nullable>
+        <NoWarn>CS1591</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="System.CommandLine.DragonFruit" Version="0.3.0-alpha.19405.1" />
+      <PackageReference Include="System.CommandLine.DragonFruit" Version="0.4.0-alpha.22114.1" />
     </ItemGroup>
 
 </Project>
diff --git a/ListingManager/Program.cs b/ListingManager/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@`
`8`	`8`
`9`	`9`	`namespace ListingManager`
`10`	`10`	`{`
	`11`	`+ /// <summary>`
	`12`	`+ /// A utility class providing means to rename listings, namespaces, and corresponding unit tests.`
	`13`	`+ /// </summary>`
`11`	`14`	`public static class ListingManager`
`12`	`15`	`{`
`13`	`16`	`public static IEnumerable<string> GetAllExtraListings(string pathToStartFrom)`
`@@ -21,7 +24,7 @@ public static IEnumerable<string> GetAllExtraListings(string pathToStartFrom)`
`21`	`24`	`}`
`22`	`25`	`}`
`23`	`26`
`24`		`- private static bool TryGetListing(string listingPath, out ListingInformation listingData)`
	`27`	`+ private static bool TryGetListing(string listingPath, out ListingInformation? listingData)`
`25`	`28`	`{`
`26`	`29`	`listingData = null;`
`27`	`30`
`@@ -39,10 +42,19 @@ private static bool TryGetListing(string listingPath, out ListingInformation lis`
`39`	`42`	`return true;`
`40`	`43`	`}`
`41`	`44`
	`45`	`+ /// <summary>`
	`46`	`+ /// Updates the namespace, file names, and corresponding test file of the target listing. This has a cascading`
	`47`	`+ /// effect, resulting in the renaming of subsequent listings in the same chapter.`
	`48`	`+ /// </summary>`
	`49`	`+ /// <param name="pathToChapter">Path to the target chapter</param>`
	`50`	`+ /// <param name="verbose">When true, enables verbose console output</param>`
	`51`	`+ /// <param name="preview">When true, leaves files in place and only print console output</param>`
	`52`	`+ /// <param name="byFolder">Changes a listing's chapter based on the chapter number in the chapter's path</param>`
	`53`	`+ /// <param name="chapterOnly">Changes only the chapter of the listing, leaving the listing number unchanged. Use with <paramref name="byFolder"/></param>`
`42`	`54`	`public static void UpdateChapterListingNumbers(string pathToChapter,`
`43`		`- bool verboseMode = false, bool preview = false, bool byFolder = false, bool chapterOnly = false)`
	`55`	`+ bool verbose = false, bool preview = false, bool byFolder = false, bool chapterOnly = false)`
`44`	`56`	`{`
`45`		`- var listingData = new List<ListingInformation>();`
	`57`	`+ var listingData = new List<ListingInformation?>();`
`46`	`58`
`47`	`59`
`48`	`60`	`List<string> allListings = FileManager.GetAllFilesAtPath(pathToChapter)`
`@@ -59,8 +71,9 @@ public static void UpdateChapterListingNumbers(string pathToChapter,`
`59`	`71`	`string cur = allListings[i];`
`60`	`72`
`61`	`73`	`var curListingData = listingData[i];`
	`74`	`+`
`62`	`75`
`63`		`- if (!chapterOnly && !byFolder && listingNumber == curListingData.ListingNumber) { continue; } //default`
	`76`	`+ if (curListingData is null \|\| !chapterOnly && !byFolder && listingNumber == curListingData.ListingNumber) { continue; } //default`
`64`	`77`
`65`	`78`	`string completeListingNumber = listingNumber + ""; //default`
`66`	`79`	`int listingChapterNumber = curListingData.ChapterNumber; //default`
`@@ -78,14 +91,14 @@ public static void UpdateChapterListingNumbers(string pathToChapter,`
`78`	`91`
`79`	`92`	`UpdateListingNamespace(cur, listingChapterNumber,`
`80`	`93`	`completeListingNumber,`
`81`		`- curListingData.ListingDescription, verboseMode, preview);`
	`94`	`+ curListingData.ListingDescription, verbose, preview);`
`82`	`95`
`83`	`96`	`if (GetPathToAccompanyingUnitTest(cur, out string pathToTest))`
`84`	`97`	`{`
`85`	`98`	`Console.Write("Updating test. ");`
`86`	`99`	`UpdateListingNamespace(pathToTest, listingChapterNumber,`
`87`	`100`	`completeListingNumber,`
`88`		`- curListingData.ListingDescription, verboseMode, preview);`
	`101`	`+ string.IsNullOrEmpty(curListingData.ListingDescription) ? "Tests" : curListingData.ListingDescription + ".Tests", verbose, preview);`
`89`	`102`	`}`
`90`	`103`
`91`	`104`	`}`
`@@ -96,14 +109,22 @@ public static bool IsExtraListing(string path,`
`96`	`109`	`{`
`97`	`110`	`Regex fileNameRegex = new Regex(regexNamespace);`
`98`	`111`
`99`		`- string directoryNameFull = Path.GetDirectoryName(path);`
`100`		`-`
	`112`	`+ string directoryNameFull = Path.GetDirectoryName(path) ?? string.Empty;`
`101`	`113`	`string directoryName = Path.GetFileName(directoryNameFull);`
`102`	`114`
`103`	`115`	`return fileNameRegex.IsMatch(path) && !directoryName.Contains(".Tests");`
`104`	`116`	`}`
`105`	`117`
`106`		`- public static void UpdateListingNamespace(string path, int chapterNumber, string listingNumber,`
	`118`	`+ /// <summary>`
	`119`	`+ /// Updates the namespace and file name of the listing at <paramref name="path"/>`
	`120`	`+ /// </summary>`
	`121`	`+ /// <param name="path">The path to the target listing</param>`
	`122`	`+ /// <param name="chapterNumber">The chapter the listing belongs to</param>`
	`123`	`+ /// <param name="listingNumber">The updated listing number</param>`
	`124`	`+ /// <param name="listingData">The name of the listing to be included in the namespace/path</param>`
	`125`	`+ /// <param name="verbose">When true, enables verbose console output</param>`
	`126`	`+ /// <param name="preview">When true, leaves files in place and only print console output</param>`
	`127`	`+ private static void UpdateListingNamespace(string path, int chapterNumber, string listingNumber,`
`107`	`128`	`string listingData, bool verbose = false, bool preview = false)`
`108`	`129`	`{`
`109`	`130`	`string paddedChapterNumber = chapterNumber.ToString("00");`
`@@ -127,7 +148,7 @@ public static void UpdateListingNamespace(string path, int chapterNumber, string`
`127`	`148`	`string newFileName = string.Format(newFileNameTemplate,`
`128`	`149`	`paddedChapterNumber,`
`129`	`150`	`paddedListingNumber,`
`130`		`- string.IsNullOrWhiteSpace(listingData) ? "" : $".{listingData}");`
	`151`	`+ string.IsNullOrWhiteSpace(listingData) \|\| string.IsNullOrEmpty(listingData) ? "" : $".{listingData}");`
`131`	`152`
`132`	`153`	`if (verbose)`
`133`	`154`	`{`
`@@ -137,19 +158,19 @@ public static void UpdateListingNamespace(string path, int chapterNumber, string`
`137`	`158`	`if (!preview) UpdateNamespaceOfPath(path, newNamespace, newFileName);`
`138`	`159`	`}`
`139`	`160`
`140`		`- public static bool UpdateNamespaceOfPath(string path, string newNamespace, string newFileName = "")`
	`161`	`+ private static void UpdateNamespaceOfPath(string path, string newNamespace, string newFileName = "")`
`141`	`162`	`{`
`142`	`163`	`if (Path.GetExtension(path) != ".cs")`
`143`	`164`	`{`
`144`		`- return false;`
	`165`	`+ return;`
`145`	`166`	`}`
`146`	`167`
`147`	`168`	`// read file into memory`
`148`	`169`	`string[] allLinesInFile = File.ReadAllLines(path);`
`149`	`170`
`150`	`171`	`File.Delete(path);`
`151`	`172`
`152`		`- string targetPath = Path.Combine(Path.GetDirectoryName(path), newFileName) ?? path;`
	`173`	`+ string targetPath = Path.Combine(Path.GetDirectoryName(path) ?? string.Empty, newFileName) ?? path;`
`153`	`174`
`154`	`175`	`using (TextWriter textWriter = new StreamWriter(targetPath, true))`
`155`	`176`	`{`
`@@ -165,8 +186,6 @@ public static bool UpdateNamespaceOfPath(string path, string newNamespace, strin`
`165`	`186`	`}`
`166`	`187`	`}`
`167`	`188`	`}`
`168`		`-`
`169`		`- return true;`
`170`	`189`	`}`
`171`	`190`
`172`	`191`	`public static bool GetPathToAccompanyingUnitTest(string listingPath, out string pathToTest)`
`@@ -200,7 +219,7 @@ public static bool GetPathToAccompanyingUnitTest(string listingPath, out string`
`200`	`219`	`return false;`
`201`	`220`	`}`
`202`	`221`
`203`		`- public static string GetTestLayout(string chapterNumber, string listingNumber)`
	`222`	`+ private static string GetTestLayout(string chapterNumber, string listingNumber)`
`204`	`223`	`{`
`205`	`224`	`return string.Format(TestHeaderLayout,`
`206`	`225`	`chapterNumber.PadLeft(2, '0'),`
`@@ -226,7 +245,7 @@ public void UnitTest1()`
`226`	`245`	`}`
`227`	`246`	`}";`
`228`	`247`
`229`		`- public static IEnumerable<string> GetAllMissingUnitTests(string pathToChapter)`
	`248`	`+ private static IEnumerable<string> GetAllMissingUnitTests(string pathToChapter)`
`230`	`249`	`{`
`231`	`250`	`foreach (string file in FileManager.GetAllFilesAtPath(pathToChapter).OrderBy(x => x))`
`232`	`251`	`{`
`@@ -237,7 +256,7 @@ public static IEnumerable<string> GetAllMissingUnitTests(string pathToChapter)`
`237`	`256`	`}`
`238`	`257`	`}`
`239`	`258`
`240`		`- public static ICollection<string> GenerateUnitTests(string pathToChapter, Func<string, bool> action = null,`
	`259`	`+ public static ICollection<string> GenerateUnitTests(string pathToChapter, Func<string, bool>? action = null,`
`241`	`260`	`bool verbose = false)`
`242`	`261`	`{`
`243`	`262`	`var toReturn = new List<string>();`
`@@ -267,7 +286,7 @@ public static ICollection<string> GenerateUnitTests(string pathToChapter, Func<s`
`267`	`286`	`return toReturn;`
`268`	`287`	`}`
`269`	`288`
`270`		`- public static bool GenerateUnitTest(string pathToTest)`
	`289`	`+ private static bool GenerateUnitTest(string pathToTest)`
`271`	`290`	`{`
`272`	`291`	`if (File.Exists(pathToTest))`
`273`	`292`	`{`