test: Added more tests for normal distribution functions (#885)

* Added a feature to allow the generation of a random number on a normal distribution

Added two functions to number.h, which are overloads of each other. One will generate a number on a normal distribution given a mean and standard deviation, the other does the same but limits the output to a certain minimum and maximum value

Added the relevant unit tests to number_test.cpp

* Update number.h

* added requested changes

* Expanded on binary string generation functionality

-Added functionality to generate a binary string which has a decimal equivalent within a specified range

-Removed use of unisgned integers, as they can lead to unintended overflows

* Update string.cpp

* Added more tests for normal distribution

* asd

* wordVector function added

include/faker-cxx/lorem.h

@@ -1,11 +1,27 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 #include "faker-cxx/export.h"
 
 namespace faker::lorem
 {
+/**
+ * @brief Generates and returns a dynamic array consisting of random lorem words.
+ *
+ * @returns A std::vector consisting of random lorem words
+ *
+ * @param numberOfWords The number of elements in the vector which is returned
+ * 
+ * @throws std::invalid_argument if the numberOfWords is less than 0
+ * 
+ * @code
+ * faker::lorem::wordVector(3) // "temporibus", "ipsum", "alias"
+ * @endcode
+ */
+FAKER_CXX_EXPORT std::vector<std::string_view> wordVector(int numberOfWords = 3);
+
 /**
  * @brief Returns a random lorem word.
  *

src/modules/lorem.cpp

@@ -14,6 +14,22 @@
 
 namespace faker::lorem
 {
+std::vector<std::string_view> wordVector(int numberOfWords)
+{
+    if(numberOfWords < 0)
+    {
+        throw std::invalid_argument("The number of words cannot be negative");
+    }
+
+    std::vector<std::string_view> output;
+    for(int i = 0; i < numberOfWords; i++)
+    {
+        output.push_back(helper::randomElement(loremWords));
+    }
+
+    return output;
+}
+
 std::string_view word()
 {
     return helper::randomElement(loremWords);

tests/modules/lorem_test.cpp

@@ -17,6 +17,37 @@ class LoremTest : public Test
 public:
 };
 
+TEST_F(LoremTest, shouldGenerateWordVector)
+{
+    const int numberOfWords = 100;
+    const auto generatedWords = wordVector(numberOfWords);
+
+    ASSERT_EQ(generatedWords.size(), numberOfWords);
+
+    ASSERT_TRUE
+    (
+        std::ranges::all_of(generatedWords,
+        [](const std::string_view& generatedWord)
+        {
+            return std::ranges::any_of (
+            loremWords, [generatedWord](const std::string_view& loremWord)
+            {
+                return loremWord == generatedWord;
+            }); 
+        }));
+}
+
+TEST_F(LoremTest, givenInvalidArguments_shouldThrowInvalidArgument)
+{
+    ASSERT_THROW(wordVector(-1), std::invalid_argument);
+}
+
+TEST_F(LoremTest, givenLengthOf0_shouldReturnEmptyVector)
+{
+    const auto generatedWords = wordVector(0);
+    ASSERT_TRUE(generatedWords.empty());
+}
+
 TEST_F(LoremTest, shouldGenerateWord)
 {
     const auto generatedWord = word();

tests/modules/number_test.cpp

@@ -105,4 +105,18 @@ TEST_F(NumberTest, givenRangeWithSameNumberSection_shouldGenerateTheExactNumber)
     const std::floating_point auto normalDistributionNumber = normalDistribution<float>(10.f, 1000.f, 12.f, 12.f);
 
     ASSERT_TRUE(normalDistributionNumber == 12.f);
+}
+
+TEST_F(NumberTest, givenHighRange_shouldGenerateMin)
+{
+    const std::floating_point auto normalDistributionNumber = normalDistribution<float>(-100, .0001f, 10000.f, 10001.f);
+
+    ASSERT_TRUE(normalDistributionNumber == 10000.f);
+}
+
+TEST_F(NumberTest, givenHighRange_shouldGenerateMax)
+{
+    const std::floating_point auto normalDistributionNum = normalDistribution<float>(10000, .0001f, -10001.f, -10000.f);
+
+    ASSERT_TRUE(normalDistributionNum == -10000.f);
 }