diff --git a/mathics/builtin/testing_expressions/numerical_properties.py b/mathics/builtin/testing_expressions/numerical_properties.py
index 6b6612ee5..02300159a 100644
--- a/mathics/builtin/testing_expressions/numerical_properties.py
+++ b/mathics/builtin/testing_expressions/numerical_properties.py
@@ -258,12 +258,15 @@ class Negative(Builtin):
      = False
     >> Negative[a + b]
      = Negative[a + b]
+    >> {Negative[Infinity], Negative[-Infinity]}
+     = {False, True}
     """
 
     attributes = A_LISTABLE | A_PROTECTED
 
     rules = {
         "Negative[x_?NumericQ]": "If[x < 0, True, False, False]",
+        "Negative[DirectedInfinity[x_?NumericQ]]": "Negative[x]",
     }
     summary_text = "test whether an expression is a negative number"
 
@@ -285,6 +288,7 @@ class NonNegative(Builtin):
 
     rules = {
         "NonNegative[x_?NumericQ]": "If[x >= 0, True, False, False]",
+        "NonNegative[DirectedInfinity[x_?NumericQ]]": "NonNegative[x]",
     }
     summary_text = "test whether an expression is a non-negative number"
 
@@ -306,6 +310,7 @@ class NonPositive(Builtin):
 
     rules = {
         "NonPositive[x_?NumericQ]": "If[x <= 0, True, False, False]",
+        "NonPositive[DirectedInfinity[x_?NumericQ]]": "NonPositive[x]",
     }
     summary_text = "test whether an expression is a non-positive number"
 
@@ -513,6 +518,7 @@ class Positive(Builtin):
 
     rules = {
         "Positive[x_?NumericQ]": "If[x > 0, True, False, False]",
+        "Positive[DirectedInfinity[x_?NumericQ]]": "Positive[x]",
     }
     summary_text = "test whether an expression is a positive number"
 
diff --git a/test/builtin/test_testing_expressions.py b/test/builtin/test_testing_expressions.py
index 4dd16437f..1ec8ccdd4 100644
--- a/test/builtin/test_testing_expressions.py
+++ b/test/builtin/test_testing_expressions.py
@@ -134,6 +134,44 @@ def test_equality_inequality(str_expr, msgs, str_expected, fail_msg):
         ("Positive[Sin[{11, 14}]]", None, "{False, True}", None),
         ("PrimeQ[1]", None, "False", None),
         ("PrimeQ[2 ^ 255 - 1]", None, "False", None),
+        # Real infinities
+        ("{Negative[Infinity], Negative[-Infinity]}", None, "{False, True}", None),
+        ("{Positive[Infinity], Positive[-Infinity]}", None, "{True, False}", None),
+        (
+            "{NonNegative[Infinity], NonNegative[-Infinity]}",
+            None,
+            "{True, False}",
+            None,
+        ),
+        (
+            "{NonPositive[Infinity], NonPositive[-Infinity]}",
+            None,
+            "{False, True}",
+            None,
+        ),
+        ("Negative[2 {Infinity, 3} - {3, 0}]", None, "{False, False}", None),
+        ("Negative[ComplexInfinity]", None, "Negative[ComplexInfinity]", None),
+        # Other directions: the sign test of the direction, as in WMA
+        (
+            "{Positive[DirectedInfinity[1.]], Negative[DirectedInfinity[-1/2]],"
+            " NonNegative[DirectedInfinity[Pi]], NonPositive[DirectedInfinity[-Sqrt[2]]]}",
+            None,
+            "{True, True, True, True}",
+            None,
+        ),
+        (
+            "{Positive[DirectedInfinity[I]], Negative[DirectedInfinity[1 + I]],"
+            " NonNegative[DirectedInfinity[-I]], NonPositive[DirectedInfinity[I]]}",
+            None,
+            "{False, False, False, False}",
+            None,
+        ),
+        (
+            "Head[Positive[DirectedInfinity[x]]]",
+            None,
+            "Positive",
+            "A symbolic direction is left undecided",
+        ),
     ],
 )
 def test_numerical_properties(str_expr, msgs, str_expected, fail_msg):