Update repr tests to avoid checking whitespace

Author: MilesCranmer

test/test_simplification.jl

@@ -2,6 +2,14 @@ include("test_params.jl")
 using DynamicExpressions, Test
 import SymbolicUtils: simplify, Symbolic
 import Random: MersenneTwister
+import Base: ≈
+
+function Base.:≈(a::String, b::String)
+    a = replace(a, r"\s+" => "")
+    b = replace(b, r"\s+" => "")
+    return a == b
+end
+
 
 simplify_tree = DynamicExpressions.SimplifyEquationModule.simplify_tree
 combine_operators = DynamicExpressions.SimplifyEquationModule.combine_operators
@@ -33,10 +41,10 @@ tree = convert(Node, eqn2, operators)
 # that SymbolicUtils does not convert it to a power:
 tree = Node("x1") * Node("x1")
 eqn = convert(Symbolic, tree, operators)
-@test repr(eqn) == "x1*x1"
+@test repr(eqn) ≈ "x1*x1"
 # Test converting back:
 tree_copy = convert(Node, eqn, operators)
-@test repr(tree_copy) == "(x1 * x1)"
+@test repr(tree_copy) ≈ "(x1*x1)"
 
 # Let's test a much more complex function,
 # with custom operators, and unary operators:
@@ -105,42 +113,42 @@ x1, x2, x3 = [Node(; feature=i) for i in 1:3]
 
 # unary operator applied to constant => constant:
 tree = Node(1, Node(; val=0.0))
-@test repr(tree) == "cos(0.0)"
-@test repr(simplify_tree(tree, operators)) == "1.0"
+@test repr(tree) ≈ "cos(0.0)"
+@test repr(simplify_tree(tree, operators)) ≈ "1.0"
 
 # except when the result is a NaN, then we don't change it:
 tree = Node(1, Node(; val=NaN))
-@test repr(tree) == "cos(NaN)"
-@test repr(simplify_tree(tree, operators)) == "cos(NaN)"
+@test repr(tree) ≈ "cos(NaN)"
+@test repr(simplify_tree(tree, operators)) ≈ "cos(NaN)"
 
 # the same as above, but inside a binary tree.
 tree =
     Node(1, Node(1, Node(; val=0.1), Node(; val=0.2)) + Node(; val=0.2)) + Node(; val=2.0)
-@test repr(tree) == "(cos((0.1 + 0.2) + 0.2) + 2.0)"
-@test repr(combine_operators(tree, operators)) == "(cos(0.4 + 0.1) + 2.0)"
+@test repr(tree) ≈ "(cos((0.1 + 0.2) + 0.2) + 2.0)"
+@test repr(combine_operators(tree, operators)) ≈ "(cos(0.4 + 0.1) + 2.0)"
 
 # left is constant:
 tree = Node(; val=0.5) + (Node(; val=0.2) + x1)
-@test repr(tree) == "(0.5 + (0.2 + x1))"
-@test repr(combine_operators(tree, operators)) == "(x1 + 0.7)"
+@test repr(tree) ≈ "(0.5 + (0.2 + x1))"
+@test repr(combine_operators(tree, operators)) ≈ "(x1 + 0.7)"
 
 # (const - (const - var)) => (var - const)
 tree = Node(2, Node(; val=0.5), Node(; val=0.2) - x1)
-@test repr(tree) == "(0.5 - (0.2 - x1))"
-@test repr(combine_operators(tree, operators)) == "(x1 - -0.3)"
+@test repr(tree) ≈ "(0.5 - (0.2 - x1))"
+@test repr(combine_operators(tree, operators)) ≈ "(x1 - -0.3)"
 
 # ((const - var) - const) => (const - var)
 tree = Node(2, Node(; val=0.5) - x1, Node(; val=0.2))
-@test repr(tree) == "((0.5 - x1) - 0.2)"
-@test repr(combine_operators(tree, operators)) == "(0.3 - x1)"
+@test repr(tree) ≈ "((0.5 - x1) - 0.2)"
+@test repr(combine_operators(tree, operators)) ≈ "(0.3 - x1)"
 
 # (const - (var - const)) => (const - var)
 tree = Node(2, Node(; val=0.5), x1 - Node(; val=0.2))
-@test repr(tree) == "(0.5 - (x1 - 0.2))"
-@test repr(combine_operators(tree, operators)) == "(0.7 - x1)"
+@test repr(tree) ≈ "(0.5 - (x1 - 0.2))"
+@test repr(combine_operators(tree, operators)) ≈ "(0.7 - x1)"
 
 # ((var - const) - const) => (var - const)
 tree = ((x1 - 0.2) - 0.6)
-@test repr(tree) == "((x1 - 0.2) - 0.6)"
-@test repr(combine_operators(tree, operators)) == "(x1 - 0.8)"
+@test repr(tree) ≈ "((x1 - 0.2) - 0.6)"
+@test repr(combine_operators(tree, operators)) ≈ "(x1 - 0.8)"
 ###############################################################################