Add ZenUnit::RandomNegative<T>() and ZenUnit::RandomPositive<T>()

Author: NeilJustice

ZenUnitAndMetalMock/ZenUnit.h

@@ -7810,7 +7810,19 @@ or change TEST(TestName) to TESTNXN(TestName, ...), where N can be 1 through 10,
       return randomInteger;
    }
 
-   template<typename T>
+   template<std::signed_integral T>
+   T RandomNegative()
+   {
+      T randomInteger = Random<T>();
+      static const T zeroValue{0};
+      while (randomInteger >= zeroValue)
+      {
+         randomInteger = Random<T>();
+      }
+      return randomInteger;
+   }
+
+   template<std::integral T>
    T RandomNonNegative()
    {
       static_assert(!std::is_same_v<T, std::string>);
@@ -7823,6 +7835,18 @@ or change TEST(TestName) to TESTNXN(TestName, ...), where N can be 1 through 10,
       return randomInteger;
    }
 
+   template<std::integral T>
+   T RandomPositive()
+   {
+      T randomInteger = Random<T>();
+      static const T zeroValue{0};
+      while (randomInteger <= zeroValue)
+      {
+         randomInteger = Random<T>();
+      }
+      return randomInteger;
+   }
+
    template<typename T>
    T RandomNon0NotEqualTo(const T& notEqualValue)
    {

ZenUnitUtilsAndAssertionTests/StaticComponents/RandomTests.cpp

@@ -16,7 +16,9 @@ namespace ZenUnit
    AFACT(RandomNon0_ReturnsNon0RandomValueBetweenMinAndMaxForTypeT)
    AFACT(RandomNon0_TIsEnum_ReturnsRandomEnumBetween1AndEnumMaxValue)
 
-   AFACT(RandomNonNegative_ReturnsNonNegative)
+   AFACT(RandomNegative_ReturnsNegativeInteger)
+   AFACT(RandomNonNegative_ReturnsNonNegativeInteger)
+   AFACT(RandomPositive_ReturnsPositiveInteger)
 
    AFACT(RandomNotEqualTo_ReturnsRandomValueBetweenMinAndMaxForTypeTNotEqualToTheExceptValue)
 
@@ -174,15 +176,33 @@ namespace ZenUnit
       SETS_ARE_EQUAL(expectedRandomEnumsReturned, randomEnumsReturned);
    }
 
-   TEST(RandomNonNegative_ReturnsNonNegative)
+   TEST(RandomNegative_ReturnsNegativeInteger)
    {
-      const int value = ZenUnit::RandomNonNegative<int>();
-      IS_GREATER_THAN_OR_EQUAL(value, 0);
+      const int intValue = ZenUnit::RandomNegative<int>();
+      IS_LESS_THAN(intValue, 0);
+
+      const short shortValue = ZenUnit::RandomNegative<short>();
+      IS_LESS_THAN(shortValue, 0);
+   }
+
+   TEST(RandomNonNegative_ReturnsNonNegativeInteger)
+   {
+      const int intValue = ZenUnit::RandomNonNegative<int>();
+      IS_GREATER_THAN_OR_EQUAL(intValue, 0);
 
       const unsigned unsignedValue = ZenUnit::RandomNonNegative<unsigned>();
       IS_GREATER_THAN_OR_EQUAL(unsignedValue, 0U);
    }
 
+   TEST(RandomPositive_ReturnsPositiveInteger)
+   {
+      const int intValue = ZenUnit::RandomPositive<int>();
+      IS_GREATER_THAN(intValue, 0);
+
+      const unsigned unsignedValue = ZenUnit::RandomPositive<unsigned>();
+      IS_GREATER_THAN(unsignedValue, 0U);
+   }
+
    TEST(RandomNotEqualTo_ReturnsRandomValueBetweenMinAndMaxForTypeTNotEqualToTheExceptValue)
    {
       const char char1 = ZenUnit::Random<char>();