Merge pull request #8 from MrUnbelievable92/1.0.10

MrUnbelievable92 · web-flow · commit b9e07c4d63de · 2024-11-14T18:13:06.000+01:00
v1.0.10
diff --git a/AssemblyInfo.cs b/AssemblyInfo.cs
@@ -9,7 +9,7 @@
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("C Sharp Dev Tools")]
-[assembly: AssemblyCopyright("Copyright � 2020 - 2023 Maximilian Kalimon")]
+[assembly: AssemblyCopyright("Copyright � 2020 - 2024 Maximilian Kalimon")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -29,5 +29,5 @@
 //      Revision
 //
 //
-[assembly: AssemblyVersion("1.0.9")]
-[assembly: AssemblyFileVersion("1.0.9")]
+[assembly: AssemblyVersion("1.0.10")]
+[assembly: AssemblyFileVersion("1.0.10")]
diff --git a/Assert.Group.cs b/Assert.Group.cs
@@ -44,6 +44,7 @@ internal GroupAttribute(string publicName)
 
             internal string FileContent { get; private set; }
             internal string PublicName { get; private set; }
+
             internal static Assert.GroupAttribute[] Defines => new Assert.GroupAttribute[]
             {
                 new Assert.GroupAttribute{ FileContent = __FILE__BOOLEAN_CONDITION_CHECKS, PublicName = __NAME__BOOLEAN_CONDITION_CHECKS },
@@ -54,23 +55,28 @@ internal GroupAttribute(string publicName)
                 new Assert.GroupAttribute{ FileContent = __FILE__ARITHMETIC_LOGIC_CHECKS,  PublicName = __NAME__ARITHMETIC_LOGIC_CHECKS  },
                 new Assert.GroupAttribute{ FileContent = __FILE__MEMORY_CHECKS,            PublicName = __NAME__MEMORY_CHECKS            }
             };
+            private static string[] KnownUsingsWithAssertClasses => new string[]
+            {
+                "using NUnit.Framework;",
+                "using UnityEngine.Assertions",
+                "using static System.Diagnostics.Debug;"
+            };
 
-            internal static async Task<Dictionary<Assert.GroupAttribute, ulong>> CountMethodCallsAsync(string projectPath)
+            internal static async Task<Dictionary<Assert.GroupAttribute, uint>> CountMethodCallsAsync(string projectPath)
             {
                 try
                 {
                     Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap = GetAssertionsMappedToGroups();
-                    List<Task<Dictionary<Assert.GroupAttribute, ulong>>> jobs = CreateCountingTasks(methodToGroupMap, projectPath);
+                    List<Task<Dictionary<Assert.GroupAttribute, uint>>> jobs = CreateCountingTasks(methodToGroupMap, projectPath);
 
-                    return await CombineResults(jobs, methodToGroupMap);
+                    return await CombineResults(jobs);
                 }
                 catch (Exception ex)
                 {
                     ex.Log();
                     return null;
                 }
             }
-
             private static bool ContainsOverload(Dictionary<MethodInfo, Assert.GroupAttribute> result, MethodInfo method)
             {
                 foreach (KeyValuePair<MethodInfo, Assert.GroupAttribute> item in result)
@@ -104,9 +110,7 @@ private static string GetMethodPrefixFromUsingStatements(string script)
                 {
                     return string.Empty;
                 }
-                else if (script.Contains("using DevTools;") &&
-                        !script.Contains("using NUnit.Framework;") &&
-                        !script.Contains("using static System.Diagnostics.Debug;"))
+                else if (script.Contains("using DevTools;") && KnownUsingsWithAssertClasses.All(__using => !script.Contains(__using)))
                 {
                     return "Assert.";
                 }
@@ -129,9 +133,9 @@ private static uint CountSubstrings(string instance, string value)
 
                 return count;
             }
-            private static List<Task<Dictionary<Assert.GroupAttribute, ulong>>> CreateCountingTasks(Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap, string path)
+            private static List<Task<Dictionary<Assert.GroupAttribute, uint>>> CreateCountingTasks(Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap, string path)
             {
-                List<Task<Dictionary<Assert.GroupAttribute, ulong>>> tasks = new List<Task<Dictionary<Assert.GroupAttribute, ulong>>>(256);
+                List<Task<Dictionary<Assert.GroupAttribute, uint>>> tasks = new List<Task<Dictionary<Assert.GroupAttribute, uint>>>(256);
 
                 DirectoryExtensions.ForEachFile(path,
                 (file) =>
@@ -141,17 +145,17 @@ private static uint CountSubstrings(string instance, string value)
                         return;
                     }
 
-                    tasks.Add(Task<Dictionary<Assert.GroupAttribute, ulong>>.Factory.StartNew(
+                    tasks.Add(Task<Dictionary<Assert.GroupAttribute, uint>>.Factory.StartNew(
                     () =>
                     {
-                        Dictionary<Assert.GroupAttribute, ulong> callCounts = new Dictionary<Assert.GroupAttribute, ulong>();
+                        Dictionary<Assert.GroupAttribute, uint> callCounts = new Dictionary<Assert.GroupAttribute, uint>();
                         string script = File.ReadAllText(file);
                         string prefix = GetMethodPrefixFromUsingStatements(script);
 
                         foreach (KeyValuePair<MethodInfo, Assert.GroupAttribute> methodMapping in methodToGroupMap)
                         {
                             Assert.GroupAttribute group = methodMapping.Value;
-                            ulong numCalls = CountSubstrings(script, prefix + methodMapping.Key.Name);
+                            uint numCalls = CountSubstrings(script, prefix + methodMapping.Key.Name);
 
                             if (callCounts.ContainsKey(group))
                             {
@@ -169,13 +173,13 @@ private static uint CountSubstrings(string instance, string value)
 
                 return tasks;
             }
-            private static async Task<Dictionary<Assert.GroupAttribute, ulong>> CombineResults(List<Task<Dictionary<Assert.GroupAttribute, ulong>>> jobs, Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap)
+            private static async Task<Dictionary<Assert.GroupAttribute, uint>> CombineResults(List<Task<Dictionary<Assert.GroupAttribute, uint>>> jobs)
             {
-                Dictionary<Assert.GroupAttribute, ulong> result = await jobs[0]; // at the very least this very script is assigned a job
+                Dictionary<Assert.GroupAttribute, uint> result = await jobs[0]; // at the very least this very script is assigned a job
 
                 for (int i = 1; i < jobs.Count; i++)
                 {
-                    foreach (KeyValuePair<Assert.GroupAttribute, ulong> callCount in await jobs[i])
+                    foreach (KeyValuePair<Assert.GroupAttribute, uint> callCount in await jobs[i])
                     {
                         result[callCount.Key] += callCount.Value;
                     }
diff --git a/Assert.cs b/Assert.cs
@@ -505,7 +505,7 @@ public static void IsSmallerOrEqual<T>(T value, T limit)
             where T : IComparable<T>
         {
 #if COMPARISON_CHECKS
-            if (value.CompareTo(limit) == 1)
+            if (value.CompareTo(limit) > 0)
             {
                 throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be smaller than or equal to { limit }.");
             }
@@ -519,7 +519,7 @@ public static void IsSmaller<T>(T value, T limit)
             where T : IComparable<T>
         {
 #if COMPARISON_CHECKS
-            if (value.CompareTo(limit) != -1)
+            if (value.CompareTo(limit) > -1)
             {
                 throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be smaller than { limit }.");
             }
@@ -533,7 +533,7 @@ public static void IsGreaterOrEqual<T>(T value, T limit)
             where T : IComparable<T>
         {
 #if COMPARISON_CHECKS
-            if (value.CompareTo(limit) == -1)
+            if (value.CompareTo(limit) < 0)
             {
                 throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be greater than or equal to { limit }.");
             }
@@ -547,7 +547,7 @@ public static void IsGreater<T>(T value, T limit)
             where T : IComparable<T>
         {
 #if COMPARISON_CHECKS
-            if (value.CompareTo(limit) != 1)
+            if (value.CompareTo(limit) < 1)
             {
                 throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be greater than { limit }.");
             }
@@ -561,7 +561,7 @@ public static void IsNotSmaller<T>(T value, T limit)
             where T : IComparable<T>
         {
 #if COMPARISON_CHECKS
-            if (value.CompareTo(limit) == -1)
+            if (value.CompareTo(limit) < 0)
             {
                 throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected not to be smaller than { limit }.");
             }
@@ -575,7 +575,7 @@ public static void IsNotGreater<T>(T value, T limit)
             where T : IComparable<T>
         {
 #if COMPARISON_CHECKS
-            if (value.CompareTo(limit) == 1)
+            if (value.CompareTo(limit) > 0)
             {
                 throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected not to be greater than { limit }.");
             }
diff --git a/Unity/Editor/SafetyCheckSettingsWindow.cs b/Unity/Editor/SafetyCheckSettingsWindow.cs
@@ -20,7 +20,7 @@ internal class SafetyCheckSettingsWindow : EditorWindow
         private bool firstLoad;
         private bool anythingChanged;
 
-        private Dictionary<Assert.GroupAttribute, ulong> methodCallCounts = null;
+        private Dictionary<Assert.GroupAttribute, uint> methodCallCounts = null;
         private Dictionary<Assert.GroupAttribute, bool> definesToCheckMarks;
 
 
@@ -48,7 +48,7 @@ private ulong TotalMethodCalls
             {
                 ulong count = 0;
 
-                foreach (KeyValuePair<Assert.GroupAttribute, ulong> assertion in methodCallCounts)
+                foreach (KeyValuePair<Assert.GroupAttribute, uint> assertion in methodCallCounts)
                 {
                     count += assertion.Value;
                 }
diff --git a/UnreachableException.cs b/UnreachableException.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 
 namespace DevTools
 {
diff --git a/manifest.json b/manifest.json
@@ -1,7 +1,7 @@
 {
   "name": "csharpdevtools",
   "displayName": "C Sharp Dev Tools",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "C Sharp Dev Tools is a small framework for defensive development with conditionally compiled assertions and logging tools.",
   "author": {
     "name": "Maximilian Kalimon",
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "csharpdevtools",
   "displayName": "C Sharp Dev Tools",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "C Sharp Dev Tools is a small framework for defensive development with conditionally compiled assertions and logging tools.",
   "author": {
     "name": "Maximilian Kalimon",

Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ internal GroupAttribute(string publicName)`
`44`	`44`
`45`	`45`	`internal string FileContent { get; private set; }`
`46`	`46`	`internal string PublicName { get; private set; }`
	`47`	`+`
`47`	`48`	`internal static Assert.GroupAttribute[] Defines => new Assert.GroupAttribute[]`
`48`	`49`	`{`
`49`	`50`	`new Assert.GroupAttribute{ FileContent = __FILE__BOOLEAN_CONDITION_CHECKS, PublicName = __NAME__BOOLEAN_CONDITION_CHECKS },`
`@@ -54,23 +55,28 @@ internal GroupAttribute(string publicName)`
`54`	`55`	`new Assert.GroupAttribute{ FileContent = __FILE__ARITHMETIC_LOGIC_CHECKS, PublicName = __NAME__ARITHMETIC_LOGIC_CHECKS },`
`55`	`56`	`new Assert.GroupAttribute{ FileContent = __FILE__MEMORY_CHECKS, PublicName = __NAME__MEMORY_CHECKS }`
`56`	`57`	`};`
	`58`	`+ private static string[] KnownUsingsWithAssertClasses => new string[]`
	`59`	`+ {`
	`60`	`+ "using NUnit.Framework;",`
	`61`	`+ "using UnityEngine.Assertions",`
	`62`	`+ "using static System.Diagnostics.Debug;"`
	`63`	`+ };`
`57`	`64`
`58`		`- internal static async Task<Dictionary<Assert.GroupAttribute, ulong>> CountMethodCallsAsync(string projectPath)`
	`65`	`+ internal static async Task<Dictionary<Assert.GroupAttribute, uint>> CountMethodCallsAsync(string projectPath)`
`59`	`66`	`{`
`60`	`67`	`try`
`61`	`68`	`{`
`62`	`69`	`Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap = GetAssertionsMappedToGroups();`
`63`		`- List<Task<Dictionary<Assert.GroupAttribute, ulong>>> jobs = CreateCountingTasks(methodToGroupMap, projectPath);`
	`70`	`+ List<Task<Dictionary<Assert.GroupAttribute, uint>>> jobs = CreateCountingTasks(methodToGroupMap, projectPath);`
`64`	`71`
`65`		`- return await CombineResults(jobs, methodToGroupMap);`
	`72`	`+ return await CombineResults(jobs);`
`66`	`73`	`}`
`67`	`74`	`catch (Exception ex)`
`68`	`75`	`{`
`69`	`76`	`ex.Log();`
`70`	`77`	`return null;`
`71`	`78`	`}`
`72`	`79`	`}`
`73`		`-`
`74`	`80`	`private static bool ContainsOverload(Dictionary<MethodInfo, Assert.GroupAttribute> result, MethodInfo method)`
`75`	`81`	`{`
`76`	`82`	`foreach (KeyValuePair<MethodInfo, Assert.GroupAttribute> item in result)`
`@@ -104,9 +110,7 @@ private static string GetMethodPrefixFromUsingStatements(string script)`
`104`	`110`	`{`
`105`	`111`	`return string.Empty;`
`106`	`112`	`}`
`107`		`- else if (script.Contains("using DevTools;") &&`
`108`		`- !script.Contains("using NUnit.Framework;") &&`
`109`		`- !script.Contains("using static System.Diagnostics.Debug;"))`
	`113`	`+ else if (script.Contains("using DevTools;") && KnownUsingsWithAssertClasses.All(__using => !script.Contains(__using)))`
`110`	`114`	`{`
`111`	`115`	`return "Assert.";`
`112`	`116`	`}`
`@@ -129,9 +133,9 @@ private static uint CountSubstrings(string instance, string value)`
`129`	`133`
`130`	`134`	`return count;`
`131`	`135`	`}`
`132`		`- private static List<Task<Dictionary<Assert.GroupAttribute, ulong>>> CreateCountingTasks(Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap, string path)`
	`136`	`+ private static List<Task<Dictionary<Assert.GroupAttribute, uint>>> CreateCountingTasks(Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap, string path)`
`133`	`137`	`{`
`134`		`- List<Task<Dictionary<Assert.GroupAttribute, ulong>>> tasks = new List<Task<Dictionary<Assert.GroupAttribute, ulong>>>(256);`
	`138`	`+ List<Task<Dictionary<Assert.GroupAttribute, uint>>> tasks = new List<Task<Dictionary<Assert.GroupAttribute, uint>>>(256);`
`135`	`139`
`136`	`140`	`DirectoryExtensions.ForEachFile(path,`
`137`	`141`	`(file) =>`
`@@ -141,17 +145,17 @@ private static uint CountSubstrings(string instance, string value)`
`141`	`145`	`return;`
`142`	`146`	`}`
`143`	`147`
`144`		`- tasks.Add(Task<Dictionary<Assert.GroupAttribute, ulong>>.Factory.StartNew(`
	`148`	`+ tasks.Add(Task<Dictionary<Assert.GroupAttribute, uint>>.Factory.StartNew(`
`145`	`149`	`() =>`
`146`	`150`	`{`
`147`		`- Dictionary<Assert.GroupAttribute, ulong> callCounts = new Dictionary<Assert.GroupAttribute, ulong>();`
	`151`	`+ Dictionary<Assert.GroupAttribute, uint> callCounts = new Dictionary<Assert.GroupAttribute, uint>();`
`148`	`152`	`string script = File.ReadAllText(file);`
`149`	`153`	`string prefix = GetMethodPrefixFromUsingStatements(script);`
`150`	`154`
`151`	`155`	`foreach (KeyValuePair<MethodInfo, Assert.GroupAttribute> methodMapping in methodToGroupMap)`
`152`	`156`	`{`
`153`	`157`	`Assert.GroupAttribute group = methodMapping.Value;`
`154`		`- ulong numCalls = CountSubstrings(script, prefix + methodMapping.Key.Name);`
	`158`	`+ uint numCalls = CountSubstrings(script, prefix + methodMapping.Key.Name);`
`155`	`159`
`156`	`160`	`if (callCounts.ContainsKey(group))`
`157`	`161`	`{`
`@@ -169,13 +173,13 @@ private static uint CountSubstrings(string instance, string value)`
`169`	`173`
`170`	`174`	`return tasks;`
`171`	`175`	`}`
`172`		`- private static async Task<Dictionary<Assert.GroupAttribute, ulong>> CombineResults(List<Task<Dictionary<Assert.GroupAttribute, ulong>>> jobs, Dictionary<MethodInfo, Assert.GroupAttribute> methodToGroupMap)`
	`176`	`+ private static async Task<Dictionary<Assert.GroupAttribute, uint>> CombineResults(List<Task<Dictionary<Assert.GroupAttribute, uint>>> jobs)`
`173`	`177`	`{`
`174`		`- Dictionary<Assert.GroupAttribute, ulong> result = await jobs[0]; // at the very least this very script is assigned a job`
	`178`	`+ Dictionary<Assert.GroupAttribute, uint> result = await jobs[0]; // at the very least this very script is assigned a job`
`175`	`179`
`176`	`180`	`for (int i = 1; i < jobs.Count; i++)`
`177`	`181`	`{`
`178`		`- foreach (KeyValuePair<Assert.GroupAttribute, ulong> callCount in await jobs[i])`
	`182`	`+ foreach (KeyValuePair<Assert.GroupAttribute, uint> callCount in await jobs[i])`
`179`	`183`	`{`
`180`	`184`	`result[callCount.Key] += callCount.Value;`
`181`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -505,7 +505,7 @@ public static void IsSmallerOrEqual<T>(T value, T limit)`
`505`	`505`	`where T : IComparable<T>`
`506`	`506`	`{`
`507`	`507`	`#if COMPARISON_CHECKS`
`508`		`- if (value.CompareTo(limit) == 1)`
	`508`	`+ if (value.CompareTo(limit) > 0)`
`509`	`509`	`{`
`510`	`510`	`throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be smaller than or equal to { limit }.");`
`511`	`511`	`}`
`@@ -519,7 +519,7 @@ public static void IsSmaller<T>(T value, T limit)`
`519`	`519`	`where T : IComparable<T>`
`520`	`520`	`{`
`521`	`521`	`#if COMPARISON_CHECKS`
`522`		`- if (value.CompareTo(limit) != -1)`
	`522`	`+ if (value.CompareTo(limit) > -1)`
`523`	`523`	`{`
`524`	`524`	`throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be smaller than { limit }.");`
`525`	`525`	`}`
`@@ -533,7 +533,7 @@ public static void IsGreaterOrEqual<T>(T value, T limit)`
`533`	`533`	`where T : IComparable<T>`
`534`	`534`	`{`
`535`	`535`	`#if COMPARISON_CHECKS`
`536`		`- if (value.CompareTo(limit) == -1)`
	`536`	`+ if (value.CompareTo(limit) < 0)`
`537`	`537`	`{`
`538`	`538`	`throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be greater than or equal to { limit }.");`
`539`	`539`	`}`
`@@ -547,7 +547,7 @@ public static void IsGreater<T>(T value, T limit)`
`547`	`547`	`where T : IComparable<T>`
`548`	`548`	`{`
`549`	`549`	`#if COMPARISON_CHECKS`
`550`		`- if (value.CompareTo(limit) != 1)`
	`550`	`+ if (value.CompareTo(limit) < 1)`
`551`	`551`	`{`
`552`	`552`	`throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected to be greater than { limit }.");`
`553`	`553`	`}`
`@@ -561,7 +561,7 @@ public static void IsNotSmaller<T>(T value, T limit)`
`561`	`561`	`where T : IComparable<T>`
`562`	`562`	`{`
`563`	`563`	`#if COMPARISON_CHECKS`
`564`		`- if (value.CompareTo(limit) == -1)`
	`564`	`+ if (value.CompareTo(limit) < 0)`
`565`	`565`	`{`
`566`	`566`	`throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected not to be smaller than { limit }.");`
`567`	`567`	`}`
`@@ -575,7 +575,7 @@ public static void IsNotGreater<T>(T value, T limit)`
`575`	`575`	`where T : IComparable<T>`
`576`	`576`	`{`
`577`	`577`	`#if COMPARISON_CHECKS`
`578`		`- if (value.CompareTo(limit) == 1)`
	`578`	`+ if (value.CompareTo(limit) > 0)`
`579`	`579`	`{`
`580`	`580`	`throw new ArgumentOutOfRangeException(ASSERTION_FAILED_TAG + $"{ value } was expected not to be greater than { limit }.");`
`581`	`581`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal class SafetyCheckSettingsWindow : EditorWindow`
`20`	`20`	`private bool firstLoad;`
`21`	`21`	`private bool anythingChanged;`
`22`	`22`
`23`		`- private Dictionary<Assert.GroupAttribute, ulong> methodCallCounts = null;`
	`23`	`+ private Dictionary<Assert.GroupAttribute, uint> methodCallCounts = null;`
`24`	`24`	`private Dictionary<Assert.GroupAttribute, bool> definesToCheckMarks;`
`25`	`25`
`26`	`26`
`@@ -48,7 +48,7 @@ private ulong TotalMethodCalls`
`48`	`48`	`{`
`49`	`49`	`ulong count = 0;`
`50`	`50`
`51`		`- foreach (KeyValuePair<Assert.GroupAttribute, ulong> assertion in methodCallCounts)`
	`51`	`+ foreach (KeyValuePair<Assert.GroupAttribute, uint> assertion in methodCallCounts)`
`52`	`52`	`{`
`53`	`53`	`count += assertion.Value;`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System;`
	`1`	`+using System;`
`2`	`2`
`3`	`3`	`namespace DevTools`
`4`	`4`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "csharpdevtools",`
`3`	`3`	`"displayName": "C Sharp Dev Tools",`
`4`		`- "version": "1.0.9",`
	`4`	`+ "version": "1.0.10",`
`5`	`5`	`"description": "C Sharp Dev Tools is a small framework for defensive development with conditionally compiled assertions and logging tools.",`
`6`	`6`	`"author": {`
`7`	`7`	`"name": "Maximilian Kalimon",`