Added tests for Strings algorithms

String/CheckAnagram.js

@@ -44,7 +44,4 @@ const checkAnagram = (str1, str2) => {
   return 'Anagrams'
 }
 
-console.log(checkAnagram('abcd', 'bcad')) // should print anagram
-console.log(checkAnagram('abcd', 'abef')) // should print not anagram
-console.log(checkAnagram(10, 'abcd'))// should print Not String(s).
-console.log(checkAnagram('abs', 'abds'))// should print not anagram
+export { checkAnagram }

String/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 Anagram')
+  })
+  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/CheckPalindrome.js

@@ -21,5 +21,4 @@ const checkPalindrome = (str) => {
   return 'Palindrome'
 }
 
-console.log(checkPalindrome('madam'))
-console.log(checkPalindrome('abcd'))
+export { checkPalindrome }

String/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/PatternMatching.js

@@ -8,6 +8,9 @@ return the starting index if the given pattern is
 available in the text
 */
 const checkIfPatternExists = (text, pattern) => {
+  if (typeof text !== 'string' || typeof pattern !== 'string') {
+    throw new TypeError('Given input is not a string')
+  }
   const textLength = text.length // Store the length of the text in a variable
   const patternLength = pattern.length // Store the length of the pattern in a variable
 
@@ -22,15 +25,10 @@ const checkIfPatternExists = (text, pattern) => {
       // j + 1 is equal to the length of the pattern
       if (j + 1 === patternLength) {
         console.log(`Given pattern is found at index ${i}`)
+        return `Given pattern is found at index ${i}`
       }
     }
   }
 }
 
-const main = () => {
-  const text = 'AABAACAADAABAAAABAA'
-  const pattern = 'AABA'
-  checkIfPatternExists(text.toLowerCase(), pattern.toLowerCase())
-}
-
-main()
+export { checkIfPatternExists }

String/PatternMatching.test.js

@@ -0,0 +1,26 @@
+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/ReverseString.js

@@ -9,6 +9,9 @@
  */
 
 function ReverseStringIterative (string) {
+  if (typeof string !== 'string') {
+    throw new TypeError('The given value is not a string')
+  }
   let reversedString = ''
   let index
 
@@ -28,6 +31,9 @@ function ReverseStringIterative (string) {
  */
 
 function ReverseStringIterativeInplace (string) {
+  if (typeof string !== 'string') {
+    throw new TypeError('The given value is not a string')
+  }
   const _string = string.split('')
 
   for (let i = 0; i < Math.floor(_string.length / 2); i++) {
@@ -40,6 +46,4 @@ function ReverseStringIterativeInplace (string) {
   return _string.join('')
 }
 
-// testing
-console.log(ReverseStringIterative('Javascript'))
-console.log(ReverseStringIterativeInplace('Javascript'))
+export { ReverseStringIterative, ReverseStringIterativeInplace }

String/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/ReverseWords.js

@@ -1,4 +1,7 @@
 const reverseWords = (str) => {
+  if (typeof str !== 'string') {
+    throw new TypeError('The given value is not a string')
+  }
   // Split string into words
   // Ex. "I Love JS" => ["I", "Love", "JS"]
   const words = str.split(' ')
@@ -10,6 +13,4 @@ const reverseWords = (str) => {
   return reversedWords.join(' ')
 }
 
-// testing
-console.log(reverseWords('I Love JS'))
-console.log(reverseWords('My Name Is JavaScript'))
+export { reverseWords }

String/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')
+    }
+  )
+})

babel.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  presets: [
+    [
+      '@babel/preset-env',
+      {
+        targets: {
+          esmodules: true
+        }
+      }
+    ]
+  ]
+}

package.json

@@ -2,17 +2,26 @@
   "name": "javascript",
   "version": "1.0.0",
   "description": "A repository for All algorithms implemented in Javascript (for educational purposes only)",
+  "main": "",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest --no-cache"
   },
   "author": "TheAlgorithms",
   "license": "GPL-3.0",
   "dependencies": {
+    "@babel/core": "^7.11.6",
+    "@babel/plugin-transform-runtime": "^7.11.5",
+    "@babel/preset-env": "^7.11.5",
     "jsdom": "^16.3.0",
     "node-fetch": "2.6.1"
   },
+  "standard": {
+    "env": [ "jest" ]
+  },
   "devDependencies": {
-    "standard": "^14.3.4",
-    "doctest": "^0.17.1"
+    "babel-jest": "^26.3.0",
+    "doctest": "^0.17.1",
+    "jest": "^26.4.2",
+    "standard": "^14.3.4"
   }
 }