NUnit 4 Breaking Change Migration

NUnit4Migrate.cs

void Main()
{
	var rootDir = @"F:\GIT\Repo";
	var classicAssert = true;

	foreach (var projFile in Directory.GetFiles(rootDir, "*.*proj", SearchOption.AllDirectories))
	{
		var projContent = File.ReadAllLines(projFile);
		if (projContent.Any(line => line.Contains("NUnit", StringComparison.InvariantCultureIgnoreCase)))
		{
			var dirPath = Path.GetDirectoryName(projFile);
			var extension = Path.GetExtension(projFile);
			if (classicAssert)
			{
				switch (extension)
				{
					case ".csproj":
						ClassicAssert(dirPath, "*.cs", content => content.Contains("using NUnit.Framework;") && !content.Contains("using NUnit.Framework.Legacy;") ? content.Replace("using NUnit.Framework;", "using NUnit.Framework;\r\nusing NUnit.Framework.Legacy;") : content);
						break;

					case ".vbproj":
						ClassicAssert(dirPath, "*.vb", content => content.Contains("Imports NUnit.Framework") && !content.Contains("Imports NUnit.Framework.Legacy") ? content.Replace("Imports NUnit.Framework", "Imports NUnit.Framework\r\nImports NUnit.Framework.Legacy") : content);
						break;

					case ".fsproj":
						ClassicAssert(dirPath, "*.fs", content => content.Contains("open NUnit.Framework") && !content.Contains("open NUnit.Framework.Legacy") ? content.Replace("open NUnit.Framework", "open NUnit.Framework\r\nopen NUnit.Framework.Legacy") : content);
						break;

					default:
						throw new Exception($"Unknown project file type: {extension}");
				}
			}
			else
			{
				switch (extension)
				{
					case ".csproj":
						RegExReplaceDirectoryCSharp(dirPath);
						break;
					
					default:
						throw new Exception($"Unknown project file type: {extension}");
				}
			}
		}
	}
}

void ClassicAssert(string directory, string extension, Func<string, string> updateUsing)
{
	foreach (var file in Directory.GetFiles(directory, extension, SearchOption.AllDirectories))
	{
		var encoding = GetEncoding(file);
		var content = File.ReadAllText(file, encoding);
		var updateMade = false;
		if (content.Contains("Assert.Pass")) { content = content.Replace("Assert.Pass", "ClassicAssert.Pass"); updateMade = true; }
		if (content.Contains("Assert.Fail")) { content = content.Replace("Assert.Fail", "ClassicAssert.Fail"); updateMade = true; }
		if (content.Contains("Assert.True")) { content = content.Replace("Assert.True", "ClassicAssert.True"); updateMade = true; }
		if (content.Contains("Assert.False")) { content = content.Replace("Assert.False", "ClassicAssert.False"); updateMade = true; }
		if (content.Contains("Assert.IsTrue")) { content = content.Replace("Assert.IsTrue", "ClassicAssert.True"); updateMade = true; }
		if (content.Contains("Assert.IsFalse")) { content = content.Replace("Assert.IsFalse", "ClassicAssert.False"); updateMade = true; }
		if (content.Contains("Assert.Null")) { content = content.Replace("Assert.Null", "ClassicAssert.Null"); updateMade = true; }
		if (content.Contains("Assert.NotNull")) { content = content.Replace("Assert.NotNull", "ClassicAssert.NotNull"); updateMade = true; }
		if (content.Contains("Assert.IsNull")) { content = content.Replace("Assert.IsNull", "ClassicAssert.Null"); updateMade = true; }
		if (content.Contains("Assert.IsNotNull")) { content = content.Replace("Assert.IsNotNull", "ClassicAssert.NotNull"); updateMade = true; }
		if (content.Contains("Assert.Zero")) { content = content.Replace("Assert.Zero", "ClassicAssert.Zero"); updateMade = true; }
		if (content.Contains("Assert.NotZero")) { content = content.Replace("Assert.NotZero", "ClassicAssert.NotZero"); updateMade = true; }
		if (content.Contains("Assert.IsNaN")) { content = content.Replace("Assert.IsNaN", "ClassicAssert.IsNaN"); updateMade = true; }
		if (content.Contains("Assert.IsEmpty")) { content = content.Replace("Assert.IsEmpty", "ClassicAssert.IsEmpty"); updateMade = true; }
		if (content.Contains("Assert.IsNotEmpty")) { content = content.Replace("Assert.IsNotEmpty", "ClassicAssert.IsNotEmpty"); updateMade = true; }
		if (content.Contains("Assert.AreEqual")) { content = content.Replace("Assert.AreEqual", "ClassicAssert.AreEqual"); updateMade = true; }
		if (content.Contains("Assert.AreNotEqual")) { content = content.Replace("Assert.AreNotEqual", "ClassicAssert.AreNotEqual"); updateMade = true; }
		if (content.Contains("Assert.AreSame")) { content = content.Replace("Assert.AreSame", "ClassicAssert.AreSame"); updateMade = true; }
		if (content.Contains("Assert.AreNotSame")) { content = content.Replace("Assert.AreNotSame", "ClassicAssert.AreNotSame"); updateMade = true; }
		if (content.Contains("Assert.Contains")) { content = content.Replace("Assert.Contains", "ClassicAssert.Contains"); updateMade = true; }
		if (content.Contains("Assert.Greater")) { content = content.Replace("Assert.Greater", "ClassicAssert.Greater"); updateMade = true; }
		if (content.Contains("Assert.GreaterOrEqual")) { content = content.Replace("Assert.GreaterOrEqual", "ClassicAssert.GreaterOrEqual"); updateMade = true; }
		if (content.Contains("Assert.Less")) { content = content.Replace("Assert.Less", "ClassicAssert.Less"); updateMade = true; }
		if (content.Contains("Assert.LessOrEqual")) { content = content.Replace("Assert.LessOrEqual", "ClassicAssert.LessOrEqual"); updateMade = true; }
		if (content.Contains("Assert.Positive")) { content = content.Replace("Assert.Positive", "ClassicAssert.Positive"); updateMade = true; }
		if (content.Contains("Assert.Negative")) { content = content.Replace("Assert.Negative", "ClassicAssert.Negative"); updateMade = true; }
		if (content.Contains("Assert.IsInstanceOf")) { content = content.Replace("Assert.IsInstanceOf", "ClassicAssert.IsInstanceOf"); updateMade = true; }
		if (content.Contains("Assert.IsNotInstanceOf")) { content = content.Replace("Assert.IsNotInstanceOf", "ClassicAssert.IsNotInstanceOf"); updateMade = true; }
		if (content.Contains("Assert.IsAssignableFrom")) { content = content.Replace("Assert.IsAssignableFrom", "ClassicAssert.IsAssignableFrom"); updateMade = true; }
		if (content.Contains("Assert.IsNotAssignableFrom")) { content = content.Replace("Assert.IsNotAssignableFrom", "ClassicAssert.IsNotAssignableFrom"); updateMade = true; }
		if (content.Contains("StringClassicAssert")) { content = content.Replace("StringClassicAssert", "StringAssert"); updateMade = true; }
		if (content.Contains("CollectionClassicAssert")) { content = content.Replace("CollectionClassicAssert", "CollectionAssert"); updateMade = true; }
		if (content.Contains("FileClassicAssert")) { content = content.Replace("FileClassicAssert", "FileAssert"); updateMade = true; }
		if (content.Contains("ClassicClassicAssert")) { content = content.Replace("ClassicClassicAssert", "ClassicAssert"); updateMade = true; }

		if (content.Contains("StringAssert") ||
		   content.Contains("CollectionAssert") ||
		   content.Contains("FileAssert"))
		{
			updateMade = true;
		}

		if (updateMade)
		{
			content = updateUsing(content);
			Console.WriteLine($"Update File: {file}");
			File.WriteAllText(file, content, encoding);
		}
	}
}

void RegExReplaceDirectoryCSharp(string rootDir)
{
	Console.WriteLine($"Checking files in: {rootDir}");
	
	// With Message
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreEqual\(null\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.Null, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreEqual\((.*).GetType\(\)\s?,\s?typeof\((.*)\)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.TypeOf<$2>(), $3);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreEqual\((.*)\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.EqualTo($2), $3);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreNotEqual\((.*)\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.Not.EqualTo($2), $3);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsGreater\((.*)\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.GreaterThan($2), $3);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Greater\((.*)\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.GreaterThan($2), $3);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsLess\((.*)\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.LessThan($2), $3);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Less\((.*)\s?,\s?(.*)\s?,\s?(\"".*\"")\);", @"Assert.That($1, Is.LessThan($2), $3);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsNotNull\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Not.Null, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.NotNull\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Not.Null, $2);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsNull\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Null, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Null\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Null, $2);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsTrue\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.True, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.True\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.True, $2);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsFalse\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.False, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.False\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.False, $2);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsEmpty\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Empty, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Empty\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Empty, $2);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsNotEmpty\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Not.Empty, $2);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.NotEmpty\((.*)\s?,\s?(\"".*\"")\);", "Assert.That($1, Is.Not.Empty, $2);");

	// Without Message
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreEqual\(null\s?,\s?(.*)\);", @"Assert.That($1, Is.Null);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreEqual\((.*).GetType\(\)\s?,\s?typeof\((.*)\)\);", @"Assert.That($1, Is.TypeOf<$2>());");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreEqual\((.*)\s?,\s?(.*)\);", @"Assert.That($1, Is.EqualTo($2));");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.AreNotEqual\((.*)\s?,\s?(.*)\);", @"Assert.That($1, Is.Not.EqualTo($2));");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsGreater\((.*)\s?,\s?(.*)\);", @"Assert.That($1, Is.GreaterThan($2));");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Greater\((.*)\s?,\s?(.*)\);", @"Assert.That($1, Is.GreaterThan($2));");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsLess\((.*)\s?,\s?(.*)\);", @"Assert.That($1, Is.LessThan($2));");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Less\((.*)\s?,\s?(.*)\);", @"Assert.That($1, Is.LessThan($2));");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsNotNull\((.*)\);", "Assert.That($1, Is.Not.Null);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.NotNull\((.*)\);", "Assert.That($1, Is.Not.Null);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsNull\((.*)\);", "Assert.That($1, Is.Null);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Null\((.*)\);", "Assert.That($1, Is.Null);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsTrue\((.*)\);", "Assert.That($1, Is.True);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.True\((.*)\);", "Assert.That($1, Is.True);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsFalse\((.*)\);", "Assert.That($1, Is.False);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.False\((.*)\);", "Assert.That($1, Is.False);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsEmpty\((.*)\);", "Assert.That($1, Is.Empty);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.Empty\((.*)\);", "Assert.That($1, Is.Empty);");

	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.IsNotEmpty\((.*)\);", "Assert.That($1, Is.Not.Empty);");
	RegExReplaceFiles(rootDir, "*.cs", @"Assert\.NotEmpty\((.*)\);", "Assert.That($1, Is.Not.Empty);");
}

void RegExReplaceFiles(string rootDir, string extension, string regexSearch, string regexReplace)
{
	foreach (var file in Directory.GetFiles(rootDir, extension, SearchOption.AllDirectories))
	{
		var encoding = GetEncoding(file);
		var content = File.ReadAllText(file, encoding);
		if(Regex.Match(content, regexSearch).Success)
		{
			Console.WriteLine($"{file} :- Match for '{regexSearch}'");
			content = Regex.Replace(content, regexSearch, regexReplace, RegexOptions.Multiline);
			File.WriteAllText(file, content, encoding);
		}
		
	}
}

Encoding GetEncoding(string filename)
{
	var bom = new byte[4];
	using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read))
	{
		file.Read(bom, 0, 4);
	}

	if (bom[0] == 0x2b && bom[1] == 0x2f && bom[2] == 0x76) return Encoding.UTF7;
	if (bom[0] == 0xef && bom[1] == 0xbb && bom[2] == 0xbf) return Encoding.UTF8;
	if (bom[0] == 0xff && bom[1] == 0xfe && bom[2] == 0 && bom[3] == 0) return Encoding.UTF32; //UTF-32LE
	if (bom[0] == 0xff && bom[1] == 0xfe) return Encoding.Unicode; //UTF-16LE
	if (bom[0] == 0xfe && bom[1] == 0xff) return Encoding.BigEndianUnicode; //UTF-16BE
	if (bom[0] == 0 && bom[1] == 0 && bom[2] == 0xfe && bom[3] == 0xff) return new UTF32Encoding(true, true);  //UTF-32BE

	return Encoding.ASCII;
}