Update tests

Author: gabriele-tomassetti

Sharplasu.Tests/Model/PositionTest.cs

@@ -34,8 +34,8 @@ second line
             Assert.AreEqual(5, new Point(1, 5).Offset(code));
             Assert.AreEqual(17, new Point(1, 17).Offset(code));
             Assert.AreEqual(18, new Point(2, 0).Offset(code));
-            Assert.ThrowsException<InvalidOperationException>(() => new Point(1, 18).Offset(code));
-            Assert.ThrowsException<InvalidOperationException>(() => new Point(4, 0).Offset(code));
+            Assert.ThrowsExactly<InvalidOperationException>(() => new Point(1, 18).Offset(code));
+            Assert.ThrowsExactly<InvalidOperationException>(() => new Point(4, 0).Offset(code));
         }
 
         [TestMethod]
@@ -200,10 +200,13 @@ public void IllegalPositionAccepted()
         }
 
         [TestMethod]
-        [ExpectedException(typeof(InvalidOperationException))]
+        
         public void IllegalPositionNotAccepted()
         {
-            var position = new Position(new Point(10, 1), new Point(5, 2), validate: true);
+            Assert.ThrowsExactly<InvalidOperationException>(() =>
+            {
+                var position = new Position(new Point(10, 1), new Point(5, 2), validate: true);
+            });
         }
 
         [TestMethod]

Sharplasu.Tests/Models/SimpleLang/Models.cs

@@ -3,6 +3,25 @@ namespace Strumenta.Sharplasu.Tests.Models.SimpleLang;
 
 public static class Models
 {
+    public class EFunc : Node { };
+
+    public class EncodingFunction : EFunc
+    {
+        public string Name { get; set; }
+        public StringLiteral String { get; set; }
+    }
+
+    public class CapitalizeFunction : EFunc
+    {
+        public string Name { get; set; }
+        public StringLiteral String { get; set; }
+    }
+
+    public class FileRoot : Node
+    {
+        public List<EFunc> eFuncs { get; set; }
+    }
+
     public static CompilationUnit GetCompilationUnit()
     {
         var cu = new CompilationUnit
@@ -26,4 +45,32 @@ public static CompilationUnit GetCompilationUnit()
         cu.AssignParents();
         return cu;
     }
+
+    public static FileRoot GetExampleCompilationUnit()
+    {
+        var cu = new FileRoot()
+        {
+            eFuncs = new List<EFunc>
+            {
+                new EncodingFunction()
+                {
+                    Name = "",
+                    String = new StringLiteral
+                    {
+                        Value = "bar"
+                    }
+                },
+                new CapitalizeFunction()
+                {
+                    Name = "",
+                    String = new StringLiteral
+                    {
+                        Value = "bar"
+                    }
+                }
+            }
+        };
+        cu.AssignParents();
+        return cu;
+    }
 }

Sharplasu.Tests/SymbolResolution/AssertTest.cs

@@ -14,9 +14,9 @@ public class AssertTest
         public void TestAssertion()
         {
             var cu = DeclarativeLocalSymbolResolverTest.GetCompilationUnit();
-            Assert.ThrowsException<SymbolResolutionException>(() => cu.AssertAllReferencesResolved());
+            Assert.ThrowsExactly<SymbolResolutionException>(() => cu.AssertAllReferencesResolved());
             DeclarativeLocalSymbolResolverTest.GetFullSymbolResolver().ResolveSymbols(cu);
-            Assert.ThrowsException<SymbolResolutionException>(() => cu.AssertNotAllReferencesResolved());
+            Assert.ThrowsExactly<SymbolResolutionException>(() => cu.AssertNotAllReferencesResolved());
         }
 
         [TestMethod]

Sharplasu.Tests/Testing/Testing.cs

@@ -86,7 +86,7 @@ public void TestDifferentParsingResults()
             }
         };
 
-        Assert.ThrowsException<ASTDifferenceException>(() => AssertParsingResultsAreEqual(result1, result2));
+        Assert.ThrowsExactly<ASTDifferenceException>(() => AssertParsingResultsAreEqual(result1, result2));
     }
 
     [TestMethod]
@@ -214,7 +214,7 @@ public void TestAssertASTsWithDifferentNodes()
             }
         };
 
-        Assert.ThrowsException<ASTDifferenceException>(() => AssertASTsAreEqual(ast1, ast2));
+        Assert.ThrowsExactly<ASTDifferenceException>(() => AssertASTsAreEqual(ast1, ast2));
     }
 
     [TestMethod]
@@ -268,7 +268,7 @@ public void TestAssertASTsWithSameNodeTypesButDifferentNodeValues()
             }
         };
 
-        Assert.ThrowsException<ASTDifferenceException>(() => AssertASTsAreEqual(ast1, ast2));
+        Assert.ThrowsExactly<ASTDifferenceException>(() => AssertASTsAreEqual(ast1, ast2));
     }
 
     [TestMethod]
@@ -335,13 +335,13 @@ public void TestTwoDifferentNodesWithOneNullProperty()
                     }
                 }
         };
-        Assert.ThrowsException<ASTDifferenceException>(() => AssertASTsAreEqual(ast1, ast2));
+        Assert.ThrowsExactly<ASTDifferenceException>(() => AssertASTsAreEqual(ast1, ast2));
     }
 
     [TestMethod]
     public void CheckRequire()
     {
-        Assert.ThrowsException<InvalidOperationException>(() => Require(false));
-        Assert.ThrowsException<InvalidOperationException>(() => Require(false, () => "Hello. I'm an error"));
+        Assert.ThrowsExactly<InvalidOperationException>(() => Require(false));
+        Assert.ThrowsExactly<InvalidOperationException>(() => Require(false, () => "Hello. I'm an error"));
     }
 }

Sharplasu.Tests/Traversing/TraversingTest.cs

@@ -3,6 +3,8 @@
 using Strumenta.Sharplasu.Traversing;
 using Type = System.Type;
 using Expression = Strumenta.Sharplasu.Tests.Models.SimpleLang.Expression;
+using System;
+using static Strumenta.Sharplasu.Tests.Models.SimpleLang.Models;
 
 namespace Strumenta.Sharplasu.Tests
 {
@@ -29,7 +31,7 @@ public void TestWalk()
         [TestMethod]
         public void TestWalkLeavesFirst()
         {
-            var cu = Tests.Models.SimpleLang.Models.GetCompilationUnit();
+            var cu = Tests.Models.SimpleLang.Models.GetCompilationUnit();            
             TestSequences(
                 MapNodesToTypes(cu.WalkLeavesFirst()),
                     new List<System.Type>
@@ -145,18 +147,45 @@ public void TestWalkDescendants()
                 });
         }
 
+        public IEnumerable<Node> GetNotEncodingChildren(Node x)
+        {
+            if (x is FileRoot)
+            {
+                List<Node> children = new List<Node>();
+                x.WalkDescendants().ToList().ForEach(t =>
+                {
+                    children.AddRange(GetNotEncodingChildren(t));
+                });
+                return children;
+            }
+            else if (x is EncodingFunction)
+                return x.WalkChildren();
+            else
+                return Enumerable.Empty<Node>();
+        }
+        
+
         [TestMethod]
         public void TestFindAncestorOfType()
         {
             var cu = Tests.Models.SimpleLang.Models.GetCompilationUnit();
             var identifier = cu.WalkDescendants().First(n => n.GetType() == typeof(Identifier));
+            var ast = Tests.Models.SimpleLang.Models.GetExampleCompilationUnit();
+            var nodes = ast.WalkDescendants(x => {
+                return GetNotEncodingChildren(x);
+            });
+            foreach (var node in nodes)
+            {
+                Console.WriteLine(node.ToString());
+            }
             Assert.IsInstanceOfType(identifier.FindAncestorOfType<CompilationUnit>(), typeof(CompilationUnit));
             Assert.IsInstanceOfType(identifier.FindAncestorOfType<SetStatement>(), typeof(SetStatement));
             Assert.IsNull(identifier.FindAncestorOfType<DisplayStatement>());
         }
 
         private List<Type> MapNodesToTypes(IEnumerable<Node> nodeSequence)
         {
+            
             return nodeSequence.Select(node => node.GetType()).ToList();
         }
 

Sharplasu/Traversing/Structurally.cs

@@ -49,8 +49,7 @@ public static IEnumerable<Node> WalkChildren(this Node node)
                         if (item is Node)
                             children.Add(item as Node);
                     }
-                }
-                                    
+                }                                    
             });
             return children.AsEnumerable<Node>();
         }