Add tests to Math (#423)

* Add prettier config

* test: add test to check for absolute function

* chore: es5 to es6

* test: add test to check mean function

* test: add test for sum of digit

* test: add test for factorial

* test: add test for fibonnaci

* test: add test for find HCF

* test: add test for lcm

* test: add gridget test

* test: add test for mean square error

* test: add test for modular binary exponentiation

* test: add tests for palindrome

* test: add test for pascals triangle

* test: add tests for polynomial

* test: add tests for prime check

* test: add tests for reverse polish notation

* test: add tests for sieve of eratosthenes

* test: add tests for pi estimation monte carlo method

* chore: move tests to test folder

* chore: fix standardjs errors

String/test/CheckAnagram.test.js

@@ -0,0 +1,31 @@
+import { checkAnagram } from '../CheckAnagram'
+
+describe('checkAnagram', () => {
+  it.each`
+    inputOne              | inputTwo
+    ${123456}             | ${'abcd'}
+    ${[1, 2, 3, 4, 5, 6]} | ${'abcd'}
+    ${{ test: 'test' }}   | ${'abcd'}
+    ${'abcd'}             | ${123456}
+    ${'abcd'}             | ${[1, 2, 3, 4, 5, 6]}
+    ${'abcd'}             | ${{ test: 'test' }}
+  `(
+    'expects to return "Not string(s)" given values $inputOne and $inputTwo',
+    ({ inputOne, inputTwo }) => {
+      const SUT = checkAnagram(inputOne, inputTwo)
+      expect(SUT).toBe('Not string(s)')
+    }
+  )
+  it('expects to return "Not anagram" if the arguments have different lengths', () => {
+    const SUT = checkAnagram('abs', 'abds')
+    expect(SUT).toBe('Not anagrams')
+  })
+  it('expects to return "Not anagram" if the arguments are not anagrams', () => {
+    const SUT = checkAnagram('abcs', 'abds')
+    expect(SUT).toBe('Not anagrams')
+  })
+  it('expects to return "Anagram" if the arguments are anagram', () => {
+    const SUT = checkAnagram('abcd', 'bcad')
+    expect(SUT).toBe('Anagrams')
+  })
+})

String/test/CheckPalindrome.test.js

@@ -0,0 +1,16 @@
+import { checkPalindrome } from '../CheckPalindrome'
+
+describe('checkPalindrome', () => {
+  it('expects to return "Palindrome" if the given string is a palindrome', () => {
+    const SUT = checkPalindrome('madam')
+    expect(SUT).toBe('Palindrome')
+  })
+  it('expects to return "Empty string" if the given string is empty', () => {
+    const SUT = checkPalindrome('')
+    expect(SUT).toBe('Empty string')
+  })
+  it('expects to return "Not a string" if the given string is not a string', () => {
+    const SUT = checkPalindrome(123)
+    expect(SUT).toBe('Not a string')
+  })
+})

String/test/PatternMatching.test.js

@@ -0,0 +1,28 @@
+import { checkIfPatternExists } from '../PatternMatching'
+describe('checkIfPatternExists', () => {
+  it('expects to find a pattern with correct input', () => {
+    const text = 'AABAACAADAABAAAABAA'
+    const pattern = 'AABA'
+    const SUT = checkIfPatternExists(text.toLowerCase(), pattern.toLowerCase())
+    expect(SUT).toBe('Given pattern is found at index 0')
+  })
+  it('expects to return a message when there is no pattern', () => {
+    const text = 'ABCDEFG'
+    const pattern = 'AEG'
+    const SUT = checkIfPatternExists(text.toLowerCase(), pattern.toLowerCase())
+    expect(SUT).toBe(undefined)
+  })
+  it('expects to find a pattern independent of casing', () => {
+    const text = 'AbCAAAAAAB'
+    const pattern = 'abc'
+    const SUT = checkIfPatternExists(text, pattern)
+    expect(SUT).toBe(undefined)
+  })
+  it('expects to throw an error message when given inpuut is not a string', () => {
+    const text = 123444456
+    const pattern = 123
+    expect(() => checkIfPatternExists(text, pattern)).toThrow(
+      'Given input is not a string'
+    )
+  })
+})

String/test/ReverseString.test.js

@@ -0,0 +1,63 @@
+import {
+  ReverseStringIterative,
+  ReverseStringIterativeInplace
+} from '../ReverseString'
+
+describe('ReverseStringIterative', () => {
+  it('expects to reverse a simple string', () => {
+    const SUT = ReverseStringIterative('reverse')
+    expect(SUT).toEqual('esrever')
+  })
+  it('expects to reverse a string with spaces in between', () => {
+    const SUT = ReverseStringIterative('reverse me')
+    expect(SUT).toEqual('em esrever')
+  })
+  it('expects to reverse a simple string without capitalizing the first letter', () => {
+    const SUT = ReverseStringIterative('Javascript')
+    expect(SUT).toEqual('tpircsavaJ')
+  })
+  it.each`
+    input
+    ${123456}
+    ${[1, 2, 3, 4, 5, 6]}
+    ${{ test: 'test' }}
+  `(
+    'expects to throw a type error given a value that is $input',
+    ({ input }) => {
+      expect(() => {
+        ReverseStringIterative(input)
+      }).toThrow('The given value is not a string')
+    }
+  )
+  it('expects to return a empty string with an empty string is given', () => {
+    const SUT = ReverseStringIterative('')
+    expect(SUT).toEqual('')
+  })
+})
+describe('ReverseStringIterativeInplace', () => {
+  it('expects to reverse a simple string', () => {
+    const SUT = ReverseStringIterativeInplace('reverse')
+    expect(SUT).toEqual('esrever')
+  })
+  it('expects to reverse a simple string without capitalizing the first letter', () => {
+    const SUT = ReverseStringIterativeInplace('Javascript')
+    expect(SUT).toEqual('tpircsavaJ')
+  })
+  it('expects to return an empty string given an empty string', () => {
+    const SUT = ReverseStringIterativeInplace('Javascript')
+    expect(SUT).toEqual('tpircsavaJ')
+  })
+  it.each`
+    input
+    ${123456}
+    ${[1, 2, 3, 4, 5, 6]}
+    ${{ test: 'test' }}
+  `(
+    'expects to throw a type error given a value that is $input',
+    ({ input }) => {
+      expect(() => {
+        ReverseStringIterativeInplace(input)
+      }).toThrow('The given value is not a string')
+    }
+  )
+})

String/test/ReverseWords.test.js

@@ -0,0 +1,21 @@
+import { reverseWords } from '../ReverseWords'
+
+describe('reverseWords', () => {
+  it('expects to reverse words to return a joined word', () => {
+    const SUT = reverseWords('I Love JS')
+    expect(SUT).toBe('JS Love I')
+  })
+  it.each`
+    input
+    ${123456}
+    ${[1, 2, 3, 4, 5, 6]}
+    ${{ test: 'test' }}
+  `(
+    'expects to throw a type error given a value that is $input',
+    ({ input }) => {
+      expect(() => {
+        reverseWords(input)
+      }).toThrow('The given value is not a string')
+    }
+  )
+})