@haystacks/async/test/unitTest/plan/executrix/colorizer.txt

A framework to build any number or any kind of native application or automation solution.

Description: Test plan for colorizer.js

--------------------------------------------------------------------------------
testName: colorizeMessageSimple_validData
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: string (The message with the color setting applied)

testName: colorizeMessageSimple_inValidMessageString
input message: string (dfxg24346dfg)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidColorArrayString
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: string (dfxg24346dfg)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidIsForegroundString
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: string (dfxg24346dfg)
output: ?

testName: colorizeMessageSimple_inValidMessageInteger
input message: integer (123)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidMessageBoolean
input message: boolean (false)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidMessageUndefined
input message: undefined
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidMessageNaN
input message: NaN
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidColorArrayInteger
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: integer (123)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidColorArrayBoolean
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: boolean (false)
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidColorArrayUndefined
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: undefined
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidColorArrayNaN
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: NaN
input isForeground: boolean (A True or False to indicate if the color setting should be applied to the foreground or not. If False, then apply to the background)
output: ?

testName: colorizeMessageSimple_inValidIsForegroundInteger
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: integer (123)
output: ?

testName: colorizeMessageSimple_inValidIsForegroundBoolean
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: boolean (false)
output: ?

testName: colorizeMessageSimple_inValidIsForegroundUndefined
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: undefined
output: ?

testName: colorizeMessageSimple_inValidIsForegroundNaN
input message: string (The message that should be formatted and returned according to the inputs, and controlled by the system configuration setting)
input colorArray: array<integers> (The RGB color array that describes the color that should be applied to the message)
input isForeground: NaN
output: ?

testName: colorizeMessageSimple_inValidAllUndefined
input message: undefined
input colorArray: undefined
input isForeground: undefined
output: ?

testName: colorizeMessageSimple_inValidAllNaN
input message: NaN
input colorArray: NaN
input isForeground: NaN
output: ?
--------------------------------------------------------------------------------
testName: colorizeMessage_validData
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: string (A colorized version of the message)

testName: colorizeMessage_inValidMessageString
input message: string (dfxg24346dfg)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidClassNameString
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (dfxg24346dfg)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFunctionNameString
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (dfxg24346dfg)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidDebugFilesSettingString
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: string (dfxg24346dfg)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidDebugFunctionsSettingString
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: string (dfxg24346dfg)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFlatMessageLogString
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: string (dfxg24346dfg)
output: ?

testName: colorizeMessage_inValidMessageInteger
input message: integer (123)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidMessageBoolean
input message: boolean (false)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidMessageUndefined
input message: undefined
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidMessageNaN
input message: NaN
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidClassNameInteger
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: integer (123)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidClassNameBoolean
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: boolean (false)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidClassNameUndefined
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: undefined
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidClassNameNaN
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: NaN
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFunctionNameInteger
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: integer (123)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFunctionNameBoolean
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: boolean (false)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFunctionNameUndefined
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: undefined
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFunctionNameNaN
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: NaN
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidDebugFunctionsSettingInteger
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: integer (123)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidDebugFunctionsSettingBoolean
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (false)
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidDebugFunctionsSettingUndefined
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: undefined
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidDebugFunctionsSettingNaN
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: NaN
input flatMessageLog: boolean (A True or False value to indicate if we are logging a flat message or if we should do additional processing)
output: ?

testName: colorizeMessage_inValidFlatMessageLogInteger
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: integer (123)
output: ?

testName: colorizeMessage_inValidFlatMessageLogBoolean
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: boolean (false)
output: ?

testName: colorizeMessage_inValidFlatMessageLogUndefined
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: undefined
output: ?

testName: colorizeMessage_inValidFlatMessageLogNaN
input message: string (The message that should be formatted and returned to be logged to the console and/or logged to a log file)
input className: string (The name of the module/file that made the log call)
input functionName: string (The name of the function that made the log call)
input debugFilesSetting: boolean (A True or False value to indicate if the log should happen according to the file/module name)
input debugFunctionsSetting: boolean (A True or False value to indicate if the log should happen according to the function/method name)
input flatMessageLog: NaN
output: ?

testName: colorizeMessage_inValidAllUndefined
input message: undefined
input className: undefined
input functionName: undefined
input debugFilesSetting: undefined
input debugFunctionsSetting: undefined
input flatMessageLog: undefined
output: ?

testName: colorizeMessage_inValidAllNaN
input message: NaN
input className: NaN
input functionName: NaN
input debugFilesSetting: NaN
input debugFunctionsSetting: NaN
input flatMessageLog: NaN
output: ?
--------------------------------------------------------------------------------
testName: aggregateStyleSetting_validData
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: array<boolean> (An array of booleans, [0] = underline setting True or False; [1] = bold setting True or False)

testName: aggregateStyleSetting_inValidSettingValue1String
input settingValue1: string (dfxg24346dfg)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue2String
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (dfxg24346dfg)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidDefaultColorArrayString
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: string (dfxg24346dfg)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidProcessAsFontSettingString
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: string (dfxg24346dfg)
output: ?

testName: aggregateStyleSetting_inValidSettingValue1Integer
input settingValue1: integer (123)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue1Boolean
input settingValue1: boolean (false)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue1Undefined
input settingValue1: undefined
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue1NaN
input settingValue1: NaN
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue2Integer
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: integer (123)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue2Boolean
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: boolean (false)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue2Undefined
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: undefined
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidSettingValue2NaN
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: NaN
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidDefaultColorArrayInteger
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: integer (123)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidDefaultColorArrayBoolean
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: boolean (false)
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidDefaultColorArrayUndefined
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: undefined
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidDefaultColorArrayNaN
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: NaN
input processAsFontSetting: boolean (A True or False value to indicate if we are processing True = font setting, False = color setting)
output: ?

testName: aggregateStyleSetting_inValidProcessAsFontSettingInteger
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: integer (123)
output: ?

testName: aggregateStyleSetting_inValidProcessAsFontSettingBoolean
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: boolean (false)
output: ?

testName: aggregateStyleSetting_inValidProcessAsFontSettingUndefined
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: undefined
output: ?

testName: aggregateStyleSetting_inValidProcessAsFontSettingNaN
input settingValue1: string (The file level setting from the configuration file)
input settingValue2: string (The function level setting from the configuration file)
input defaultColorArray: array<integer> (The default color value that should be used)
input processAsFontSetting: NaN
output: ?

testName: aggregateStyleSetting_inValidAllUndefined
input settingValue1: undefined
input settingValue2: undefined
input defaultColorArray: undefined
input processAsFontSetting: undefined
output: ?

testName: aggregateStyleSetting_inValidAllNaN
input settingValue1: NaN
input settingValue2: NaN
input defaultColorArray: NaN
input processAsFontSetting: NaN
output: ?
--------------------------------------------------------------------------------
testName: getFontStyleSettingsFromSetting_validData
input settingValue: string (The setting value that should be parsed)
output: array<boolean> (An array of booleans, [0] = underline setting True or False; [1] = bold setting True or False)

testName: getFontStyleSettingsFromSetting_inValidSettingValueString
input settingValue: string (dfxg24346dfg)
output: ?

testName: getFontStyleSettingsFromSetting_inValidSettingValueInteger
input settingValue: integer (123)
output: ?

testName: getFontStyleSettingsFromSetting_inValidSettingValueBoolean
input settingValue: boolean (false)
output: ?

testName: getFontStyleSettingsFromSetting_inValidSettingValueUndefined
input settingValue: undefined
output: ?

testName: getFontStyleSettingsFromSetting_inValidSettingValueNaN
input settingValue: NaN
output: ?
--------------------------------------------------------------------------------
testName: getColorStyleSettingFromSetting_validData
input settingValue: string (The setting value, which could be RGB as in R,G,B or it could be a string-name as in a unique color name)
input defaultColorArray: array<integer> (The default color value that should be used)
output: object (A JSON object with three integers that represent RGB values, labeled as "Red", "Green", "Blue")

testName: getColorStyleSettingFromSetting_inValidSettingValueString
input settingValue: string (dfxg24346dfg)
input defaultColorArray: array<integer> (The default color value that should be used)
output: ?

testName: getColorStyleSettingFromSetting_inValidDefaultColorArrayString
input settingValue: string (The setting value, which could be RGB as in R,G,B or it could be a string-name as in a unique color name)
input defaultColorArray: string (dfxg24346dfg)
output: ?

testName: getColorStyleSettingFromSetting_inValidSettingValueInteger
input settingValue: integer (123)
input defaultColorArray: array<integer> (The default color value that should be used)
output: ?

testName: getColorStyleSettingFromSetting_inValidSettingValueBoolean
input settingValue: boolean (false)
input defaultColorArray: array<integer> (The default color value that should be used)
output: ?

testName: getColorStyleSettingFromSetting_inValidDefaultColorArrayInteger
input settingValue: string (The setting value, which could be RGB as in R,G,B or it could be a string-name as in a unique color name)
input defaultColorArray: integer (123)
output: ?

testName: getColorStyleSettingFromSetting_inValidDefaultColorArrayBoolean
input settingValue: string (The setting value, which could be RGB as in R,G,B or it could be a string-name as in a unique color name)
input defaultColorArray: boolean (false)
output: ?

testName: getColorStyleSettingFromSetting_inValidSettingValueUndefined
input settingValue: undefined
input defaultColorArray: array<integer> (The default color value that should be used)
output: ?

testName: getColorStyleSettingFromSetting_inValidSettingValueNaN
input settingValue: NaN
input defaultColorArray: array<integer> (The default color value that should be used)
output: ?

testName: getColorStyleSettingFromSetting_inValidDefaultColorArrayUndefined
input settingValue: string (The setting value, which could be RGB as in R,G,B or it could be a string-name as in a unique color name)
input defaultColorArray: undefined
output: ?

testName: getColorStyleSettingFromSetting_inValidDefaultColorArrayNaN
input settingValue: string (The setting value, which could be RGB as in R,G,B or it could be a string-name as in a unique color name)
input defaultColorArray: NaN
output: ?
--------------------------------------------------------------------------------
testName: getNamedColorData_validData
input colorName: string (The name of the color who's RGB value we should look up from the color data structure)
input defaultColorArray: array<integer> (The default color that should be used)
output: array<integer> (An array of integers that represent RGB values)

testName: getNamedColorData_inValidColorNameString
input colorName: string (dfxg24346dfg)
input defaultColorArray: array<integer> (The default color that should be used)
output: ?

testName: getNamedColorData_inValidDefaultColorArrayString
input colorName: string (The name of the color who's RGB value we should look up from the color data structure)
input defaultColorArray: string (dfxg24346dfg)
output: ?

testName: getNamedColorData_inValidColorNameInteger
input colorName: integer (123)
input defaultColorArray: array<integer> (The default color that should be used)
output: ?

testName: getNamedColorData_inValidColorNameBoolean
input colorName: boolean (false)
input defaultColorArray: array<integer> (The default color that should be used)
output: ?

testName: getNamedColorData_inValidDefaultColorArrayInteger
input colorName: string (The name of the color who's RGB value we should look up from the color data structure)
input defaultColorArray: integer (123)
output: ?

testName: getNamedColorData_inValidDefaultColorArrayBoolean
input colorName: string (The name of the color who's RGB value we should look up from the color data structure)
input defaultColorArray: boolean (false)
output: ?

testName: getNamedColorData_inValidColorNameUndefined
input colorName: undefined
input defaultColorArray: array<integer> (The default color that should be used)
output: ?

testName: getNamedColorData_inValidColorNameNaN
input colorName: NaN
input defaultColorArray: array<integer> (The default color that should be used)
output: ?

testName: getNamedColorData_inValidDefaultColorArrayUndefined
input colorName: string (The name of the color who's RGB value we should look up from the color data structure)
input defaultColorArray: undefined
output: ?

testName: getNamedColorData_inValidDefaultColorArrayNaN
input colorName: string (The name of the color who's RGB value we should look up from the color data structure)
input defaultColorArray: NaN
output: ?
--------------------------------------------------------------------------------
testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_validData
input messageComponent: string (The message to which the underline font setting should be applied if the setting value calls for it)
input underlineSettingValue: boolean (A True or False value to indicate if the underline font setting should be applied or not applied)
output: string (The same as the input string, except perhaps it might have an underline setting applied to it)

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentString
input messageComponent: string (dfxg24346dfg)
input underlineSettingValue: boolean (A True or False value to indicate if the underline font setting should be applied or not applied)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidUnderlineSettingValueString
input messageComponent: string (The message to which the underline font setting should be applied if the setting value calls for it)
input underlineSettingValue: string (dfxg24346dfg)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentInteger
input messageComponent: integer (123)
input underlineSettingValue: boolean (A True or False value to indicate if the underline font setting should be applied or not applied)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentBoolean
input messageComponent: boolean (false)
input underlineSettingValue: boolean (A True or False value to indicate if the underline font setting should be applied or not applied)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidUnderlineSettingValueInteger
input messageComponent: string (The message to which the underline font setting should be applied if the setting value calls for it)
input underlineSettingValue: integer (123)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidUnderlineSettingValueBoolean
input messageComponent: string (The message to which the underline font setting should be applied if the setting value calls for it)
input underlineSettingValue: boolean (false)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentUndefined
input messageComponent: undefined
input underlineSettingValue: boolean (A True or False value to indicate if the underline font setting should be applied or not applied)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentNaN
input messageComponent: NaN
input underlineSettingValue: boolean (A True or False value to indicate if the underline font setting should be applied or not applied)
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidUnderlineSettingValueUndefined
input messageComponent: string (The message to which the underline font setting should be applied if the setting value calls for it)
input underlineSettingValue: undefined
output: ?

testName: setUnderlineFontStyleOnMessageComponentAccordingToSetting_inValidUnderlineSettingValueNaN
input messageComponent: string (The message to which the underline font setting should be applied if the setting value calls for it)
input underlineSettingValue: NaN
output: ?
--------------------------------------------------------------------------------
testName: setBoldFontStyleOnMessageComponentAccordingToSetting_validData
input messageComponent: string (The message to which the bold font setting should be applied if the setting value calls for it)
input boldSettingValue: boolean (A True or False value to indicate if the bold font setting should be applied or not applied)
output: string (The same as the input string, except perhaps it might have a bold setting applied to it)

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentString
input messageComponent: string (dfxg24346dfg)
input boldSettingValue: boolean (?)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidBoldSettingValueString
input messageComponent: string (?)
input boldSettingValue: string (dfxg24346dfg)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentInteger
input messageComponent: integer (123)
input boldSettingValue: boolean (?)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentBoolean
input messageComponent: boolean (false)
input boldSettingValue: boolean (?)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidBoldSettingValueInteger
input messageComponent: string (?)
input boldSettingValue: integer (123)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidBoldSettingValueBoolean
input messageComponent: string (?)
input boldSettingValue: boolean (false)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentUndefined
input messageComponent: undefined
input boldSettingValue: boolean (?)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidMessageComponentNaN
input messageComponent: NaN
input boldSettingValue: boolean (?)
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidBoldSettingValueUndefined
input messageComponent: string (?)
input boldSettingValue: undefined
output: ?

testName: setBoldFontStyleOnMessageComponentAccordingToSetting_inValidBoldSettingValueNaN
input messageComponent: string (?)
input boldSettingValue: NaN
output: ?
--------------------------------------------------------------------------------
testName: setFontForegroundColorOnMessageComponentAccordingToSetting_validData
input messageComponent: string (The message to which the foreground color setting should be applied if the color setting value != false)
input colorSettingValue: boolean|array<integer> (A value of False or an array of integers for RGB values. False if no color should be applied)
output: string (The same as the input string, except perhaps it might have a foreground color setting applied to it)

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidMessageComponentString
input messageComponent: string (dfxg24346dfg)
input colorSettingValue: boolean|array<integer> (A value of False or an array of integers for RGB values. False if no color should be applied)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidColorSettingValueString
input messageComponent: string (The message to which the foreground color setting should be applied if the color setting value != false)
input colorSettingValue: string (dfxg24346dfg)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidMessageComponentInteger
input messageComponent: integer (123)
input colorSettingValue: boolean|array<integer> (A value of False or an array of integers for RGB values. False if no color should be applied)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidMessageComponentBoolean
input messageComponent: boolean (false)
input colorSettingValue: boolean|array<integer> (A value of False or an array of integers for RGB values. False if no color should be applied)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidColorSettingValueInteger
input messageComponent: string (The message to which the foreground color setting should be applied if the color setting value != false)
input colorSettingValue: integer (123)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidColorSettingValueBoolean
input messageComponent: string (The message to which the foreground color setting should be applied if the color setting value != false)
input colorSettingValue: boolean (false)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidMessageComponentUndefined
input messageComponent: undefined
input colorSettingValue: boolean|array<integer> (A value of False or an array of integers for RGB values. False if no color should be applied)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidMessageComponentNaN
input messageComponent: NaN
input colorSettingValue: boolean|array<integer> (A value of False or an array of integers for RGB values. False if no color should be applied)
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidColorSettingValueUndefined
input messageComponent: string (The message to which the foreground color setting should be applied if the color setting value != false)
input colorSettingValue: undefined
output: ?

testName: setFontForegroundColorOnMessageComponentAccordingToSetting_inValidColorSettingValueNaN
input messageComponent: string (The message to which the foreground color setting should be applied if the color setting value != false)
input colorSettingValue: NaN
output: ?
--------------------------------------------------------------------------------
testName: setFontBackgroundColorOnMessageComponentAccordingToSetting_validData
input messageComponent: string (The message to which the background color setting should be applied if the color setting value != false)
input colorSettingValue: boolean|array<integer> (A value