description: Test plan for wordArrayParsing.js


--------------------------------------------------------------------------------
testName: convertCamelCaseStringToArray_validDataString
input inputData: string (String to decompose into an array)
input inputMetaData: string (Not used for this business rule)
output: array<string> (The array of words that were composed in the original string)

testName: convertCamelCaseStringToArray_inValidDataInputDataString
input inputData: string (dfxg24346dfg)
input inputMetaData: string (Not used for this business rule) (testDataString)
output: ?

testName: convertCamelCaseStringToArray_inValidDataInputMetaDataString
input inputData: string (String to decompose into an array) (testDataString)
input inputMetaData: string (dfxg24346dfg)
output: ?

testName: convertCamelCaseStringToArray_inValidInputDataInteger
input inputData: integer (4567)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: convertCamelCaseStringToArray_inValidInputDataBoolean
input inputData: boolean (false)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: convertCamelCaseStringToArray_inValidInputMetaDataInteger
input inputData: array ([1,2,3,4,5])
input inputMetaData: integer (4567)
output: ?
status: Failed
error: TypeError: inputData.charAt is not a function

testName: convertCamelCaseStringToArray_inValidInputMetaDataBoolean
input inputData: array ([1,2,3,4,5])
input inputMetaData: boolean (false)
output: ?
status: Failed
error: TypeError: inputData.charAt is not a function
--------------------------------------------------------------------------------
testName: getWordsArrayFromString_validDataString
input inputData: string (The string that should be broken down into words and returned as an array)
input inputMetaData: string (Not used for this business rule)
output: array<string> (The array of words found in the string)

testName: getWordsArrayFromString_inValidDataInputDataString
input inputData: string (dfxg24346dfg)
input inputMetaData: string (Not used for this business rule) (testDataString)
output: ?

testName: getWordsArrayFromString_inValidDataInputMetaDataString
input inputData: string (The string that should be broken down into words and returned as an array) (testDataString)
input inputMetaData: string (dfxg24346dfg)
output: ?

testName: getWordsArrayFromString_inValidInputDataInteger
input inputData: integer (4567)
input inputMetaData: array ([1,2,3,4,5])
output: ?
status: Failed
error: TypeError: inputData.split is not a function

testName: getWordsArrayFromString_inValidInputDataBoolean
input inputData: boolean (false)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: getWordsArrayFromString_inValidInputMetaDataInteger
input inputData: array ([1,2,3,4,5])
input inputMetaData: integer (4567)
output: ?
status: Failed
error: TypeError: inputData.charAt is not a function

testName: getWordsArrayFromString_inValidInputMetaDataBoolean
input inputData: array ([1,2,3,4,5])
input inputMetaData: boolean (false)
output: ?
status: Failed
error: TypeError: inputData.charAt is not a function
--------------------------------------------------------------------------------
testName: recombineStringArrayWithSpaces_validDataString
input inputData: array<string> (The array of strings that should be recombined)
input inputMetaData: string (Not used for this business rule)
output: string (The string array with spaces between array elements)

testName: recombineStringArrayWithSpaces_inValidDataInputDataString
input inputData: string (dfxg24346dfg)
input inputMetaData: string (Not used for this business rule) (testDataString)
output: ?
status: Failed
error: TypeError: inputData.join is not a function

testName: recombineStringArrayWithSpaces_inValidDataInputMetaDataString
input inputData: array<string> (The array of strings that should be recombined) (testDataString)
input inputMetaData: string (dfxg24346dfg)
output: ?

testName: recombineStringArrayWithSpaces_inValidInputDataInteger
input inputData: integer (4567)
input inputMetaData: array ([1,2,3,4,5])
output: ?
status: Failed
error: TypeError: inputData.join is not a function

testName: recombineStringArrayWithSpaces_inValidInputDataBoolean
input inputData: boolean (false)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: recombineStringArrayWithSpaces_inValidInputMetaDataInteger
input inputData: array ([1,2,3,4,5])
input inputMetaData: integer (4567)
output: ?

testName: recombineStringArrayWithSpaces_inValidInputMetaDataBoolean
input inputData: array ([1,2,3,4,5])
input inputMetaData: boolean (false)
output: ?

testName: recombineStringArrayWithSpaces_inValidInputDataUndefined
input inputData: undefined
input inputMetaData: string (Not used for this business rule) (inValidDataToStoreUndefined)
output: ?

testName: recombineStringArrayWithSpaces_inValidInputDataNaN
input inputData: NaN
input inputMetaData: string (Not used for this business rule) (inValidDataToStoreNaN)
output: ?
--------------------------------------------------------------------------------
testName: convertArrayToCamelCaseString_validDataString
input inputData: array<string> (The array of words that should be strung together into a single long string)
input inputMetaData: string (Not used for this business rule)
output: string (A string that contains all of the words from the input array put together in sequential order)

testName: convertArrayToCamelCaseString_inValidDataInputDataString
input inputData: string (dfxg24346dfg)
input inputMetaData: string (Not used for this business rule) (testDataString)
output: ?
status: Failed
error: TypeError: inputData.map is not a function

testName: convertArrayToCamelCaseString_inValidDataInputMetaDataString
input inputData: array<string> (The array of words that should be strung together into a single long string) (testDataString)
input inputMetaData: string (dfxg24346dfg)
output: ?

testName: convertArrayToCamelCaseString_inValidInputDataInteger
input inputData: integer (4567)
input inputMetaData: array ([1,2,3,4,5])
output: ?
status: Failed
erorr: TypeError: inputData.map is not a function

testName: convertArrayToCamelCaseString_inValidInputDataBoolean
input inputData: boolean (false)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: convertArrayToCamelCaseString_inValidInputMetaDataInteger
input inputData: array ([1,2,3,4,5])
input inputMetaData: integer (4567)
output: ?
status: Failed
error: TypeError: inputData.replace is not a function

testName: convertArrayToCamelCaseString_inValidInputMetaDataBoolean
input inputData: array ([1,2,3,4,5])
input inputMetaData: boolean (false)
output: ?
status: Failed
error: TypeError: inputData.replace is not a function

testName: convertArrayToCamelCaseString_inValidInputDataUndefined
input inputData: undefined
input inputMetaData: string (Not used for this business rule) (inValidDataToStoreUndefined)
output: ?

testName: convertArrayToCamelCaseString_inValidInputDataNaN
input inputData: NaN
input inputMetaData: string (Not used for this business rule) (inValidDataToStoreNaN)
output: ?
--------------------------------------------------------------------------------
testName: doesArrayContainLowerCaseConsolidatedString_validDataString
input inputData: array<string> (The array of strings that should be checked if it contains the specified string)
input inputMetaData: string (The string we are looking for in the array)
output: boolean

testName: doesArrayContainLowerCaseConsolidatedString_inValidDataInputDataString
input inputData: string (dfxg24346dfg)
input inputMetaData: string (The string we are looking for in the array) (testDataString)
output: ?

testName: doesArrayContainLowerCaseConsolidatedString_inValidDataInputMetaDataString
input inputData: array<string> (The array of strings that should be checked if it contains the specified string) (testDataString)
input inputMetaData: string (dfxg24346dfg)
output: ?

testName: doesArrayContainLowerCaseConsolidatedString_inValidInputDataInteger
input inputData: integer (4567)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: doesArrayContainLowerCaseConsolidatedString_inValidInputDataBoolean
input inputData: boolean (false)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: doesArrayContainLowerCaseConsolidatedString_inValidInputMetaDataInteger
input inputData: array ([1,2,3,4,5])
input inputMetaData: integer (4567)
output: ?
status: Failed
error: TypeError: inputData.toLowerCase is not a function

testName: doesArrayContainLowerCaseConsolidatedString_inValidInputMetaDataBoolean
input inputData: array ([1,2,3,4,5])
input inputMetaData: boolean (false)
output: ?

testName: doesArrayContainLowerCaseConsolidatedString_inValidInputDataUndefined
input inputData: undefined
input inputMetaData: string (The string we are looking for in the array) (inValidDataToStoreUndefined)
output: ?

testName: doesArrayContainLowerCaseConsolidatedString_inValidInputDataNaN
input inputData: NaN
input inputMetaData: string (The string we are looking for in the array) (inValidDataToStoreNaN)
output: ?
--------------------------------------------------------------------------------ascertainMatchingElements
testName: ascertainMatchingElements_validDataString
input inputData: array<string|boolean|integer|float|object> (An array that should be compared for equality)
input inputMetaData: array<string|boolean|integer|float|object> (Second array that should be compared for equality)
output: boolean

testName: ascertainMatchingElements_inValidDataInputDataString
input inputData: string (dfxg24346dfg)
input inputMetaData: array<string|boolean|integer|float|object> (Second array that should be compared for equality) (testDataString)
output: ?

testName: ascertainMatchingElements_inValidDataInputMetaDataString
input inputData: array<string|boolean|integer|float|object> (An array that should be compared for equality) (testDataString)
input inputMetaData: string (dfxg24346dfg)
output: ?

testName: ascertainMatchingElements_inValidInputDataInteger
input inputData: integer (4567)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: ascertainMatchingElements_inValidInputDataBoolean
input inputData: boolean (false)
input inputMetaData: array ([1,2,3,4,5])
output: ?

testName: ascertainMatchingElements_inValidInputMetaDataInteger
input inputData: array ([1,2,3,4,5])
input inputMetaData: integer (4567)
output: ?

testName: ascertainMatchingElements_inValidInputMetaDataBoolean
input inputData: array ([1,2,3,4,5])
input inputMetaData: boolean (false)
output: ?

testName: ascertainMatchingElements_inValidInputDataUndefined
input inputData: undefined
input inputMetaData: array<string|boolean|integer|float|object> (Second array that should be compared for equality) (inValidDataToStoreUndefined)
output: ?

testName: ascertainMatchingElements_inValidInputDataNaN
input inputData: NaN
input inputMetaData: array<string|boolean|integer|float|object> (Second array that should be compared for equality) (inValidDataToStoreNaN)
output: ?

testName: ascertainMatchingElements_inValidInputMetaDataUndefined
input inputData: array<string|boolean|integer|float|object> (An array that should be compared for equality) (inValidDataToStoreUndefined)
input inputMetaData: undefined
output: ?

testName: ascertainMatchingElements_inValidInputMetaDataNaN
input inputData: array<string|boolean|integer|float|object> (An array that should be compared for equality) (inValidDataToStoreNaN)
input inputMetaData: NaN
output: ?