From c9c8056408f5125f1297365bdee443c6199425fa Mon Sep 17 00:00:00 2001 From: Artem Date: Thu, 21 Dec 2023 17:14:16 +0300 Subject: [PATCH 1/3] =?UTF-8?q?=D0=9A=D1=80=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Kr3/Kr3.sln | 31 ++++ Kr3/Kr3/Kr3.csproj | 11 ++ Kr3/Kr3/Reflector.cs | 179 +++++++++++++++++++++++ Kr3/TestsReflector/TestClassSum.cs | 22 +++ Kr3/TestsReflector/TestsReflector.cs | 15 ++ Kr3/TestsReflector/TestsReflector.csproj | 23 +++ Kr3/TestsReflector/Usings.cs | 1 + 7 files changed, 282 insertions(+) create mode 100644 Kr3/Kr3.sln create mode 100644 Kr3/Kr3/Kr3.csproj create mode 100644 Kr3/Kr3/Reflector.cs create mode 100644 Kr3/TestsReflector/TestClassSum.cs create mode 100644 Kr3/TestsReflector/TestsReflector.cs create mode 100644 Kr3/TestsReflector/TestsReflector.csproj create mode 100644 Kr3/TestsReflector/Usings.cs diff --git a/Kr3/Kr3.sln b/Kr3/Kr3.sln new file mode 100644 index 0000000..d6690e4 --- /dev/null +++ b/Kr3/Kr3.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33403.182 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Kr3", "Kr3\Kr3.csproj", "{5B9C8390-F227-4F23-81BA-AB1885C1DF32}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestsReflector", "TestsReflector\TestsReflector.csproj", "{15B74937-BD20-4D2E-BBC1-49BA7ABDCF10}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {5B9C8390-F227-4F23-81BA-AB1885C1DF32}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5B9C8390-F227-4F23-81BA-AB1885C1DF32}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5B9C8390-F227-4F23-81BA-AB1885C1DF32}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5B9C8390-F227-4F23-81BA-AB1885C1DF32}.Release|Any CPU.Build.0 = Release|Any CPU + {15B74937-BD20-4D2E-BBC1-49BA7ABDCF10}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {15B74937-BD20-4D2E-BBC1-49BA7ABDCF10}.Debug|Any CPU.Build.0 = Debug|Any CPU + {15B74937-BD20-4D2E-BBC1-49BA7ABDCF10}.Release|Any CPU.ActiveCfg = Release|Any CPU + {15B74937-BD20-4D2E-BBC1-49BA7ABDCF10}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {B0556365-C55B-4AF6-8ACA-ACBA1E439626} + EndGlobalSection +EndGlobal diff --git a/Kr3/Kr3/Kr3.csproj b/Kr3/Kr3/Kr3.csproj new file mode 100644 index 0000000..424caff --- /dev/null +++ b/Kr3/Kr3/Kr3.csproj @@ -0,0 +1,11 @@ + + + + Exe + net7.0 + enable + enable + Library + + + diff --git a/Kr3/Kr3/Reflector.cs b/Kr3/Kr3/Reflector.cs new file mode 100644 index 0000000..de3f395 --- /dev/null +++ b/Kr3/Kr3/Reflector.cs @@ -0,0 +1,179 @@ +using System.Reflection; + +namespace Kr3; + +public class Reflector +{ + private string filePath; + + public Reflector(string filePath) => this.filePath = filePath; + + private string GetVisibilityFromClass(Type someClass) + { + if (someClass.IsNestedPrivate) + { + return "private "; + } + else if (someClass.IsNestedPublic) + { + return "public "; + } + else if (someClass.IsNestedFamily) + { + return "protected "; + } + else if (someClass.IsNestedAssembly) + { + return "internal "; + } + return ""; + } + + private string GetStaticOrNotFromClass(Type someClass) + { + return someClass.IsAbstract && someClass.IsSealed ? "static " : ""; + } + + private string GetVisibilityFromField(FieldInfo someField) + { + if (someField.IsPrivate) + { + return "private "; + } + else if (someField.IsPublic) + { + return "public "; + } + else if (someField.IsFamily) + { + return "protected "; + } + else if (someField.IsAssembly) + { + return "internal "; + } + return ""; + } + + private string GetStaticOrNotFromField(FieldInfo someField) + { + return someField.IsStatic ? "static " : ""; + } + + private string GetStaticOrNotFromMethod(MethodInfo someMethod) + { + return someMethod.IsStatic ? "static " : ""; + } + + private string GetVisibilityFromMethod(MethodInfo someMethod) + { + if (someMethod.IsPrivate) + { + return "private "; + } + else if (someMethod.IsPublic) + { + return "public "; + } + else if (someMethod.IsFamily) + { + return "protected "; + } + else if (someMethod.IsAssembly) + { + return "internal "; + } + return ""; + } + + public void PrintStructure(Type someClass) + { + string className = someClass.Name; + string file = $"{filePath}\\{className}.cs"; + + using var writer = new StreamWriter(file); + + var visibility = GetVisibilityFromClass(someClass); + var staticOrNotStatic = GetStaticOrNotFromClass(someClass); + writer.WriteLine($"{visibility}{staticOrNotStatic}class {className}"); + writer.WriteLine("{"); + + var fields = someClass.GetFields(); + foreach (var field in fields) + { + writer.WriteLine($"\t{GetVisibilityFromField(field)}{GetStaticOrNotFromField(field)}{field.ToString()};"); + } + + var methods = someClass.GetMethods(); + foreach (var method in methods) + { + writer.WriteLine($"\t{GetVisibilityFromMethod(method)}{GetStaticOrNotFromMethod(method)}{method.ToString()} {{throw OperationCanceledException();}};"); + } + + var nestedClasses = someClass.GetNestedTypes(); + foreach (var nestedClass in nestedClasses) + { + PrintStructure(nestedClass); + } + + writer.WriteLine("}"); + } + + private bool CheckIfThereIsMethodFromOneClassInAnother(MethodInfo[] methodsB, MethodInfo methodA) + { + var methodB = methodsB.FirstOrDefault(m => m.Name == methodA.Name && m.GetParameters(). + Select(p => p.ParameterType).SequenceEqual(methodA.GetParameters().Select(p => p.ParameterType))); + return methodB != null ? true : false; + } + + private void WriteDifferentMethods(StreamWriter writer, + MethodInfo[] methodsFirst, MethodInfo[] methodsSecond) + { + foreach (var methodA in methodsFirst) + { + if (!CheckIfThereIsMethodFromOneClassInAnother(methodsSecond, methodA)) + { + writer.WriteLine($"{methodA.Name}"); + } + } + } + private void WriteDifferentFields(StreamWriter writer, + FieldInfo[] fieldsFirst, FieldInfo[] fieldsSecond) + { + foreach (var fieldA in fieldsFirst) + { + if (!CheckIfThereIsFieldFromOneClassInAnother(fieldsSecond, fieldA)) + { + writer.WriteLine($"{fieldA.Name}"); + } + } + } + + private bool CheckIfThereIsFieldFromOneClassInAnother(FieldInfo[] fieldsB, FieldInfo fieldA) + { + var fieldB = fieldsB.FirstOrDefault(f => f.Name == fieldA.Name && f.FieldType == fieldA.FieldType); + return fieldB != null ? true : false; + } + + public void DiffClasses(Type a, Type b) + { + string file = $"{filePath}/difference.cs"; + + using var writer = new StreamWriter(file); + + WriteDifferentFields(writer, a.GetFields(), b.GetFields()); + WriteDifferentFields(writer, b.GetFields(), a.GetFields()); + WriteDifferentMethods(writer, a.GetMethods(), b.GetMethods()); + WriteDifferentMethods(writer, b.GetMethods(), a.GetMethods()); + + var nestedClassesA = a.GetNestedTypes(); + var nestedClassesB = b.GetNestedTypes(); + foreach (var nestedClassA in nestedClassesA) + { + foreach (var nestedClassB in nestedClassesB) + { + DiffClasses(nestedClassA, nestedClassB); + } + } + } +} \ No newline at end of file diff --git a/Kr3/TestsReflector/TestClassSum.cs b/Kr3/TestsReflector/TestClassSum.cs new file mode 100644 index 0000000..a9d2c64 --- /dev/null +++ b/Kr3/TestsReflector/TestClassSum.cs @@ -0,0 +1,22 @@ +namespace TestsReflector; + +public class TestClassSum +{ + private int val; + + public TestClassSum() + { + val = 0; + } + + public int Value + { + get { return val; } + set { val = value; } + } + + public void Add(int num) + { + val += num; + } +} \ No newline at end of file diff --git a/Kr3/TestsReflector/TestsReflector.cs b/Kr3/TestsReflector/TestsReflector.cs new file mode 100644 index 0000000..becaa10 --- /dev/null +++ b/Kr3/TestsReflector/TestsReflector.cs @@ -0,0 +1,15 @@ +namespace TestsReflector; + +using Kr3; + +public class Tests +{ + [Test] + public void TestWithTestClassSum() + { + var sum = new TestClassSum(); + var typeSum = sum.GetType(); + var reflector = new Reflector("C:\\Users\\User\\source\\repos\\HomeworksCSharp\\Kr3\\Kr3\\obj\\Debug\\net7.0\\forTests"); + reflector.PrintStructure(typeSum); + } +} \ No newline at end of file diff --git a/Kr3/TestsReflector/TestsReflector.csproj b/Kr3/TestsReflector/TestsReflector.csproj new file mode 100644 index 0000000..d1d73f9 --- /dev/null +++ b/Kr3/TestsReflector/TestsReflector.csproj @@ -0,0 +1,23 @@ + + + + net7.0 + enable + enable + + false + + + + + + + + + + + + + + + diff --git a/Kr3/TestsReflector/Usings.cs b/Kr3/TestsReflector/Usings.cs new file mode 100644 index 0000000..cefced4 --- /dev/null +++ b/Kr3/TestsReflector/Usings.cs @@ -0,0 +1 @@ +global using NUnit.Framework; \ No newline at end of file From 9153917746809c1f35059c78d64f002b31d98a68 Mon Sep 17 00:00:00 2001 From: Artem Date: Thu, 21 Dec 2023 22:43:18 +0300 Subject: [PATCH 2/3] fix --- Kr3/Kr3/Reflector.cs | 118 ++++++++++++++---- Kr3/TestsReflector/AnotherSum.cs | 16 +++ Kr3/TestsReflector/TestClassSum.cs | 10 +- Kr3/TestsReflector/TestsReflector.cs | 34 ++++- .../net7.0/forTests/CheckTestClassSum.cs | 6 + .../bin/Debug/net7.0/forTests/TestClassSum.cs | 6 + .../bin/Debug/net7.0/forTests/difference.txt | 2 + 7 files changed, 157 insertions(+), 35 deletions(-) create mode 100644 Kr3/TestsReflector/AnotherSum.cs create mode 100644 Kr3/TestsReflector/bin/Debug/net7.0/forTests/CheckTestClassSum.cs create mode 100644 Kr3/TestsReflector/bin/Debug/net7.0/forTests/TestClassSum.cs create mode 100644 Kr3/TestsReflector/bin/Debug/net7.0/forTests/difference.txt diff --git a/Kr3/Kr3/Reflector.cs b/Kr3/Kr3/Reflector.cs index de3f395..005360f 100644 --- a/Kr3/Kr3/Reflector.cs +++ b/Kr3/Kr3/Reflector.cs @@ -1,14 +1,15 @@ -using System.Reflection; +using System.Linq.Expressions; +using System.Reflection; namespace Kr3; public class Reflector { - private string filePath; + private readonly string filePath; public Reflector(string filePath) => this.filePath = filePath; - private string GetVisibilityFromClass(Type someClass) + private static string GetVisibilityFromClass(Type someClass) { if (someClass.IsNestedPrivate) { @@ -29,12 +30,12 @@ private string GetVisibilityFromClass(Type someClass) return ""; } - private string GetStaticOrNotFromClass(Type someClass) + private static string GetStaticOrNotFromClass(Type someClass) { return someClass.IsAbstract && someClass.IsSealed ? "static " : ""; } - private string GetVisibilityFromField(FieldInfo someField) + private static string GetVisibilityFromField(FieldInfo someField) { if (someField.IsPrivate) { @@ -55,17 +56,17 @@ private string GetVisibilityFromField(FieldInfo someField) return ""; } - private string GetStaticOrNotFromField(FieldInfo someField) + private static string GetStaticOrNotFromField(FieldInfo someField) { return someField.IsStatic ? "static " : ""; } - private string GetStaticOrNotFromMethod(MethodInfo someMethod) + private static string GetStaticOrNotFromMethod(MethodInfo someMethod) { return someMethod.IsStatic ? "static " : ""; } - private string GetVisibilityFromMethod(MethodInfo someMethod) + private static string GetVisibilityFromMethod(MethodInfo someMethod) { if (someMethod.IsPrivate) { @@ -86,6 +87,44 @@ private string GetVisibilityFromMethod(MethodInfo someMethod) return ""; } + private static string GetVisibilityFromConstructor(ConstructorInfo constructorInfo) + { + if (constructorInfo.IsPrivate) + { + return "private "; + } + else if (constructorInfo.IsPublic) + { + return "public "; + } + else if (constructorInfo.IsFamily) + { + return "protected "; + } + else if (constructorInfo.IsAssembly) + { + return "internal "; + } + return ""; + } + + private void WriteParameters(StreamWriter writer, ParameterInfo[] parameters) + { + var first = true; + foreach (var parameter in parameters) + { + if (first) + { + writer.Write($"{parameter.ParameterType} {parameter.Name}"); + first = false; + } + else + { + writer.Write($" ,{parameter.Name}"); + } + } + } + public void PrintStructure(Type someClass) { string className = someClass.Name; @@ -95,19 +134,50 @@ public void PrintStructure(Type someClass) var visibility = GetVisibilityFromClass(someClass); var staticOrNotStatic = GetStaticOrNotFromClass(someClass); - writer.WriteLine($"{visibility}{staticOrNotStatic}class {className}"); - writer.WriteLine("{"); + var interfaces = someClass.GetInterfaces(); + if (interfaces.Length == 0) + { + writer.Write($"{visibility}{staticOrNotStatic}class {className}\n"); + } + else + { + writer.Write($"{visibility}{staticOrNotStatic}class {className} : "); + var first = true; + foreach (var element in interfaces) + { + if (first) + { + writer.Write($"{element.Name}"); + first = false; + } + else + { + writer.Write($" : {element.Name}"); + } + } + writer.Write('\n'); + } + writer.Write("{\n"); - var fields = someClass.GetFields(); + var constructors = someClass.GetConstructors(); + foreach (var constructor in constructors) + { + writer.Write($"\t{GetVisibilityFromConstructor(constructor)}{className}("); + WriteParameters(writer, constructor.GetParameters()); + writer.Write(") {}\n"); + } + var fields = someClass.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly); foreach (var field in fields) { - writer.WriteLine($"\t{GetVisibilityFromField(field)}{GetStaticOrNotFromField(field)}{field.ToString()};"); + writer.Write($"\t{GetVisibilityFromField(field)}{GetStaticOrNotFromField(field)}{field};\n"); } - var methods = someClass.GetMethods(); + var methods = someClass.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly); foreach (var method in methods) { - writer.WriteLine($"\t{GetVisibilityFromMethod(method)}{GetStaticOrNotFromMethod(method)}{method.ToString()} {{throw OperationCanceledException();}};"); + writer.Write($"\t{GetVisibilityFromMethod(method)}{GetStaticOrNotFromMethod(method)}{method.Name} ("); + WriteParameters(writer, method.GetParameters()); + writer.Write(") {throw new OperationCanceledException()}\n"); } var nestedClasses = someClass.GetNestedTypes(); @@ -116,48 +186,48 @@ public void PrintStructure(Type someClass) PrintStructure(nestedClass); } - writer.WriteLine("}"); + writer.Write("}\n"); } - private bool CheckIfThereIsMethodFromOneClassInAnother(MethodInfo[] methodsB, MethodInfo methodA) + private static bool CheckIfThereIsMethodFromOneClassInAnother(MethodInfo[] methodsB, MethodInfo methodA) { var methodB = methodsB.FirstOrDefault(m => m.Name == methodA.Name && m.GetParameters(). Select(p => p.ParameterType).SequenceEqual(methodA.GetParameters().Select(p => p.ParameterType))); - return methodB != null ? true : false; + return methodB != null; } - private void WriteDifferentMethods(StreamWriter writer, + private static void WriteDifferentMethods(StreamWriter writer, MethodInfo[] methodsFirst, MethodInfo[] methodsSecond) { foreach (var methodA in methodsFirst) { if (!CheckIfThereIsMethodFromOneClassInAnother(methodsSecond, methodA)) { - writer.WriteLine($"{methodA.Name}"); + writer.Write($"{methodA.Name}\n"); } } } - private void WriteDifferentFields(StreamWriter writer, + private static void WriteDifferentFields(StreamWriter writer, FieldInfo[] fieldsFirst, FieldInfo[] fieldsSecond) { foreach (var fieldA in fieldsFirst) { if (!CheckIfThereIsFieldFromOneClassInAnother(fieldsSecond, fieldA)) { - writer.WriteLine($"{fieldA.Name}"); + writer.Write($"{fieldA.Name}\n"); } } } - private bool CheckIfThereIsFieldFromOneClassInAnother(FieldInfo[] fieldsB, FieldInfo fieldA) + private static bool CheckIfThereIsFieldFromOneClassInAnother(FieldInfo[] fieldsB, FieldInfo fieldA) { var fieldB = fieldsB.FirstOrDefault(f => f.Name == fieldA.Name && f.FieldType == fieldA.FieldType); - return fieldB != null ? true : false; + return fieldB != null; } public void DiffClasses(Type a, Type b) { - string file = $"{filePath}/difference.cs"; + string file = $"{filePath}/difference.txt"; using var writer = new StreamWriter(file); diff --git a/Kr3/TestsReflector/AnotherSum.cs b/Kr3/TestsReflector/AnotherSum.cs new file mode 100644 index 0000000..358739b --- /dev/null +++ b/Kr3/TestsReflector/AnotherSum.cs @@ -0,0 +1,16 @@ +namespace TestsReflector; + +public class AnotherSum +{ + private int val; + + public AnotherSum(int value) + { + val = value; + } + + public void AddToSum(int num) + { + val += num; + } +} diff --git a/Kr3/TestsReflector/TestClassSum.cs b/Kr3/TestsReflector/TestClassSum.cs index a9d2c64..534758b 100644 --- a/Kr3/TestsReflector/TestClassSum.cs +++ b/Kr3/TestsReflector/TestClassSum.cs @@ -4,15 +4,9 @@ public class TestClassSum { private int val; - public TestClassSum() + public TestClassSum(int value) { - val = 0; - } - - public int Value - { - get { return val; } - set { val = value; } + val = value; } public void Add(int num) diff --git a/Kr3/TestsReflector/TestsReflector.cs b/Kr3/TestsReflector/TestsReflector.cs index becaa10..2158a70 100644 --- a/Kr3/TestsReflector/TestsReflector.cs +++ b/Kr3/TestsReflector/TestsReflector.cs @@ -5,11 +5,39 @@ namespace TestsReflector; public class Tests { [Test] - public void TestWithTestClassSum() + public void TestWithTestPrintStructure() { - var sum = new TestClassSum(); + var sum = new TestClassSum(0); var typeSum = sum.GetType(); - var reflector = new Reflector("C:\\Users\\User\\source\\repos\\HomeworksCSharp\\Kr3\\Kr3\\obj\\Debug\\net7.0\\forTests"); + var reflector = new Reflector(Path.Combine(TestContext.CurrentContext.TestDirectory, "forTests")); reflector.PrintStructure(typeSum); + using var reader = new StreamReader((Path.Combine(TestContext.CurrentContext.TestDirectory, "forTests", "CheckTestClassSum.cs"))); + var linesForCheck = reader.ReadToEnd().Split('\n'); + using var anotherReader = new StreamReader((Path.Combine(TestContext.CurrentContext.TestDirectory, "forTests", "TestClassSum.cs"))); + var linesFromReflector = anotherReader.ReadToEnd().Split('\n'); + + var i = 0; + var j = 0; + while (i < linesForCheck.Length || j < linesFromReflector.Length) + { + Assert.That(linesForCheck[i], Is.EqualTo(linesFromReflector[j])); + ++i; + ++j; + } + } + + [Test] + public void TestWithTestClassDiffClasses() + { + var sum = new TestClassSum(0); + var typeSum = sum.GetType(); + var anotherSum = new AnotherSum(0); + var typeAnotherSum= anotherSum.GetType(); + var reflector = new Reflector(Path.Combine(TestContext.CurrentContext.TestDirectory,"forTests")); + reflector.DiffClasses(typeSum, typeAnotherSum); + using var reader = new StreamReader((Path.Combine(TestContext.CurrentContext.TestDirectory, "forTests", "difference.txt"))); + var lines = reader.ReadToEnd().Split('\n'); + Assert.That(lines[0], Is.EqualTo("Add")); + Assert.That(lines[1], Is.EqualTo("AddToSum")); } } \ No newline at end of file diff --git a/Kr3/TestsReflector/bin/Debug/net7.0/forTests/CheckTestClassSum.cs b/Kr3/TestsReflector/bin/Debug/net7.0/forTests/CheckTestClassSum.cs new file mode 100644 index 0000000..ed4710f --- /dev/null +++ b/Kr3/TestsReflector/bin/Debug/net7.0/forTests/CheckTestClassSum.cs @@ -0,0 +1,6 @@ +class TestClassSum +{ + public TestClassSum(System.Int32 value) {} + private Int32 val; + public Add (System.Int32 num) {throw new OperationCanceledException()} +} diff --git a/Kr3/TestsReflector/bin/Debug/net7.0/forTests/TestClassSum.cs b/Kr3/TestsReflector/bin/Debug/net7.0/forTests/TestClassSum.cs new file mode 100644 index 0000000..ed4710f --- /dev/null +++ b/Kr3/TestsReflector/bin/Debug/net7.0/forTests/TestClassSum.cs @@ -0,0 +1,6 @@ +class TestClassSum +{ + public TestClassSum(System.Int32 value) {} + private Int32 val; + public Add (System.Int32 num) {throw new OperationCanceledException()} +} diff --git a/Kr3/TestsReflector/bin/Debug/net7.0/forTests/difference.txt b/Kr3/TestsReflector/bin/Debug/net7.0/forTests/difference.txt new file mode 100644 index 0000000..f247286 --- /dev/null +++ b/Kr3/TestsReflector/bin/Debug/net7.0/forTests/difference.txt @@ -0,0 +1,2 @@ +Add +AddToSum From 5212603c70f25dcbb83c71cc53899c22cb9772f7 Mon Sep 17 00:00:00 2001 From: Artem Date: Thu, 21 Dec 2023 23:02:32 +0300 Subject: [PATCH 3/3] fix 2 --- Kr3/Kr3/Reflector.cs | 14 +++++++------- Kr3/TestsReflector/TestsReflector.cs | 17 ++++++++++++++--- 2 files changed, 21 insertions(+), 10 deletions(-) diff --git a/Kr3/Kr3/Reflector.cs b/Kr3/Kr3/Reflector.cs index 005360f..0f90818 100644 --- a/Kr3/Kr3/Reflector.cs +++ b/Kr3/Kr3/Reflector.cs @@ -137,7 +137,7 @@ public void PrintStructure(Type someClass) var interfaces = someClass.GetInterfaces(); if (interfaces.Length == 0) { - writer.Write($"{visibility}{staticOrNotStatic}class {className}\n"); + writer.WriteLine($"{visibility}{staticOrNotStatic}class {className}"); } else { @@ -155,21 +155,21 @@ public void PrintStructure(Type someClass) writer.Write($" : {element.Name}"); } } - writer.Write('\n'); + writer.WriteLine(); } - writer.Write("{\n"); + writer.WriteLine("{"); var constructors = someClass.GetConstructors(); foreach (var constructor in constructors) { writer.Write($"\t{GetVisibilityFromConstructor(constructor)}{className}("); WriteParameters(writer, constructor.GetParameters()); - writer.Write(") {}\n"); + writer.WriteLine(") {}"); } var fields = someClass.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly); foreach (var field in fields) { - writer.Write($"\t{GetVisibilityFromField(field)}{GetStaticOrNotFromField(field)}{field};\n"); + writer.WriteLine($"\t{GetVisibilityFromField(field)}{GetStaticOrNotFromField(field)}{field};"); } var methods = someClass.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly); @@ -177,7 +177,7 @@ public void PrintStructure(Type someClass) { writer.Write($"\t{GetVisibilityFromMethod(method)}{GetStaticOrNotFromMethod(method)}{method.Name} ("); WriteParameters(writer, method.GetParameters()); - writer.Write(") {throw new OperationCanceledException()}\n"); + writer.WriteLine(") {throw new OperationCanceledException()}"); } var nestedClasses = someClass.GetNestedTypes(); @@ -186,7 +186,7 @@ public void PrintStructure(Type someClass) PrintStructure(nestedClass); } - writer.Write("}\n"); + writer.WriteLine("}"); } private static bool CheckIfThereIsMethodFromOneClassInAnother(MethodInfo[] methodsB, MethodInfo methodA) diff --git a/Kr3/TestsReflector/TestsReflector.cs b/Kr3/TestsReflector/TestsReflector.cs index 2158a70..46a071b 100644 --- a/Kr3/TestsReflector/TestsReflector.cs +++ b/Kr3/TestsReflector/TestsReflector.cs @@ -1,6 +1,7 @@ namespace TestsReflector; using Kr3; +using System.Net.WebSockets; public class Tests { @@ -14,13 +15,23 @@ public void TestWithTestPrintStructure() using var reader = new StreamReader((Path.Combine(TestContext.CurrentContext.TestDirectory, "forTests", "CheckTestClassSum.cs"))); var linesForCheck = reader.ReadToEnd().Split('\n'); using var anotherReader = new StreamReader((Path.Combine(TestContext.CurrentContext.TestDirectory, "forTests", "TestClassSum.cs"))); - var linesFromReflector = anotherReader.ReadToEnd().Split('\n'); + var linesFromReflector = anotherReader.ReadToEnd().Split('\r'); + + var arrayStringsWithoutSpecialSymbols = new string[linesFromReflector.Length]; var i = 0; + foreach (var line in linesFromReflector) + { + var newLine = line.Replace("\n", ""); + arrayStringsWithoutSpecialSymbols[i] = newLine; + i++; + } + + i = 0; var j = 0; - while (i < linesForCheck.Length || j < linesFromReflector.Length) + while (i < linesForCheck.Length || j < arrayStringsWithoutSpecialSymbols.Length) { - Assert.That(linesForCheck[i], Is.EqualTo(linesFromReflector[j])); + Assert.That(linesForCheck[i], Is.EqualTo(arrayStringsWithoutSpecialSymbols[j])); ++i; ++j; }