diff --git a/django_expanded_test_cases/constants.py b/django_expanded_test_cases/constants.py
index 3cf45fd5028d661f855abc5cf072f25d6e6dabc0..49e62d45dca004df9a3e1e13515ba1df99beeeba 100644
--- a/django_expanded_test_cases/constants.py
+++ b/django_expanded_test_cases/constants.py
@@ -17,85 +17,86 @@ UNDERLINE = '\u001b[4m'
 UNDERLINE_RESET = '\u001b[0m'
 
 
-# General output format settings.
-ETC_OUTPUT_ERROR = str(getattr(
+# General output/color format settings.
+ETC_OUTPUT_ERROR_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_ERROR_HEADER',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_ERROR_HEADER_COLOR',
     '{0}{1}{2}'.format(Fore.RED, Back.RESET, Style.NORMAL) if COLORAMA_PRESENT else '',
 ))
-ETC_OUTPUT_EXPECTED_MATCH = str(getattr(
+ETC_OUTPUT_EXPECTED_MATCH_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_EXPECTED_MATCH',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_EXPECTED_MATCH_COLOR',
     '{0}{1}{2}'.format(Fore.CYAN, Back.RESET, Style.NORMAL) if COLORAMA_PRESENT else '',
 ))
-ETC_OUTPUT_EXPECTED_ERROR = str(getattr(
+ETC_OUTPUT_EXPECTED_ERROR_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_EXPECTED_ERROR',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_EXPECTED_ERROR_COLOR',
     '{0}{1}{2}'.format(Fore.BLACK, Back.CYAN, Style.NORMAL) if COLORAMA_PRESENT else '',
 ))
-ETC_OUTPUT_ACTUALS_MATCH = str(getattr(
+ETC_OUTPUT_ACTUALS_MATCH_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_ACTUALS_MATCH',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_ACTUALS_MATCH_COLOR',
     '{0}{1}{2}'.format(Fore.MAGENTA, Back.RESET, Style.NORMAL) if COLORAMA_PRESENT else '',
 ))
-ETC_OUTPUT_ACTUALS_ERROR = str(getattr(
+ETC_OUTPUT_ACTUALS_ERROR_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_ACTUALS_ERROR',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_ACTUALS_ERROR_COLOR',
     '{0}{1}{2}'.format(Fore.BLACK, Back.MAGENTA, Style.NORMAL) if COLORAMA_PRESENT else '',
 ))
-ETC_OUTPUT_EMPHASIS = str(getattr(
+ETC_OUTPUT_EMPHASIS_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_EMPHASIS',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_EMPHASIS_COLOR',
     (Style.BRIGHT if COLORAMA_PRESENT else '') + UNDERLINE,
 ))
-ETC_OUTPUT_RESET = str(getattr(
+ETC_OUTPUT_RESET_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_OUTPUT_RESET',
+    'DJANGO_EXPANDED_TESTCASES_OUTPUT_RESET_COLOR',
     Style.RESET_ALL if COLORAMA_PRESENT else UNDERLINE_RESET,
 ))
 
-# Output formatting for response sections.
+# Output/color formatting for response sections.
 ETC_RESPONSE_DEBUG_URL_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_URL',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_URL_COLOR',
     Fore.YELLOW if COLORAMA_PRESENT else '',
 ))
 ETC_RESPONSE_DEBUG_CONTENT_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_CONTENT',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_CONTENT_COLOR',
     Fore.WHITE if COLORAMA_PRESENT else '',
 ))
-ETC_RESPONSE_DEBUG_HEADERS_COLOR = str(getattr(
+ETC_RESPONSE_DEBUG_HEADER_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_HEADERS',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_HEADER_COLOR',
     Fore.CYAN if COLORAMA_PRESENT else '',
 ))
 ETC_RESPONSE_DEBUG_CONTEXT_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_CONTEXT',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_CONTEXT_COLOR',
     Fore.BLUE if COLORAMA_PRESENT else '',
 ))
 ETC_RESPONSE_DEBUG_SESSION_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_SESSION',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_SESSION_COLOR',
     Fore.MAGENTA if COLORAMA_PRESENT else '',
 ))
 ETC_RESPONSE_DEBUG_MESSAGE_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_MESSAGES',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_MESSAGES_COLOR',
     Fore.CYAN if COLORAMA_PRESENT else '',
 ))
 ETC_RESPONSE_DEBUG_FORM_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_FORMS',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_FORMS_COLOR',
     Fore.BLUE if COLORAMA_PRESENT else '',
 ))
 ETC_RESPONSE_DEBUG_USER_INFO_COLOR = str(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_USER_INFO',
+    'DJANGO_EXPANDED_TESTCASES_RESPONSE_OUTPUT_USER_INFO_COLOR',
     Fore.MAGENTA if COLORAMA_PRESENT else '',
 ))
 
+# Enabling/disabling output of specific sections.
 ETC_INCLUDE_RESPONSE_DEBUG_URL = bool(getattr(
     settings,
     'DJANGO_EXPANDED_TESTCASES_INCLUDE_RESPONSE_DEBUG_URL',
@@ -106,9 +107,9 @@ ETC_INCLUDE_RESPONSE_DEBUG_CONTENT = bool(getattr(
     'DJANGO_EXPANDED_TESTCASES_INCLUDE_RESPONSE_DEBUG_CONTENT',
     True,
 ))
-ETC_INCLUDE_RESPONSE_DEBUG_HEADERS = bool(getattr(
+ETC_INCLUDE_RESPONSE_DEBUG_HEADER = bool(getattr(
     settings,
-    'DJANGO_EXPANDED_TESTCASES_INCLUDE_RESPONSE_DEBUG_HEADERS',
+    'DJANGO_EXPANDED_TESTCASES_INCLUDE_RESPONSE_DEBUG_HEADER',
     True,
 ))
 ETC_INCLUDE_RESPONSE_DEBUG_CONTEXT = bool(getattr(
diff --git a/django_expanded_test_cases/mixins/core_mixin.py b/django_expanded_test_cases/mixins/core_mixin.py
index 70ed24adce223260b6416ea107b1fb7276856b38..e59d1fa1416e978962d90a4f49cb80915fcbae94 100644
--- a/django_expanded_test_cases/mixins/core_mixin.py
+++ b/django_expanded_test_cases/mixins/core_mixin.py
@@ -23,12 +23,12 @@ from django_expanded_test_cases.constants import (
     ETC_DEFAULT_INACTIVE_USER_IDENTIFIER,
     ETC_DEFAULT_USER_PASSWORD,
     ETC_GENERATE_USERS_WITH_REAL_NAMES,
-    ETC_OUTPUT_ACTUALS_ERROR,
-    ETC_OUTPUT_ACTUALS_MATCH,
-    ETC_OUTPUT_ERROR,
-    ETC_OUTPUT_EXPECTED_ERROR,
-    ETC_OUTPUT_EXPECTED_MATCH,
-    ETC_OUTPUT_RESET,
+    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+    ETC_OUTPUT_ERROR_COLOR,
+    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+    ETC_OUTPUT_RESET_COLOR,
 )
 
 
@@ -43,7 +43,7 @@ def wrapper(method):
         except AssertionError as err:
             if ETC_DEBUG_PRINT:
                 print('\n')
-                print('{0}{1}{2}'.format(ETC_OUTPUT_ERROR, err, ETC_OUTPUT_RESET))
+                print('{0}{1}{2}'.format(ETC_OUTPUT_ERROR_COLOR, err, ETC_OUTPUT_RESET_COLOR))
                 print('')
             raise err
     return wrapped
@@ -259,7 +259,7 @@ class CoreTestCaseMixin:
             print(back, end='')
             print(style, end='')
             print(*args, **kwargs, end='')
-            print(ETC_OUTPUT_RESET)
+            print(ETC_OUTPUT_RESET_COLOR)
 
     # region Custom Assertions
 
@@ -322,22 +322,22 @@ class CoreTestCaseMixin:
 
                 if curr_expected_line == curr_actual_line:
                     # Line is full match and correct.
-                    curr_expected_line = '{0}{1}{2}\n'.format(ETC_OUTPUT_EXPECTED_MATCH, curr_expected_line, ETC_OUTPUT_RESET)
-                    curr_actual_line = '{0}{1}{2}\n'.format(ETC_OUTPUT_ACTUALS_MATCH, curr_actual_line, ETC_OUTPUT_RESET)
+                    curr_expected_line = '{0}{1}{2}\n'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, curr_expected_line, ETC_OUTPUT_RESET_COLOR)
+                    curr_actual_line = '{0}{1}{2}\n'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, curr_actual_line, ETC_OUTPUT_RESET_COLOR)
                 elif curr_expected_line is None:
                     # "Actual" output is longer than "expected" output. Impossible to match current line.
                     curr_expected_line = ''
                     curr_actual_line = '{0}{1}{2}\n'.format(
-                        ETC_OUTPUT_ACTUALS_ERROR,
+                        ETC_OUTPUT_ACTUALS_ERROR_COLOR,
                         curr_actual_line,
-                        ETC_OUTPUT_RESET,
+                        ETC_OUTPUT_RESET_COLOR,
                     )
                 elif curr_actual_line is None:
                     # "Expected" output is longer than "actual" output. Impossible to match current line.
                     curr_expected_line = '{0}{1}{2}\n'.format(
-                        ETC_OUTPUT_EXPECTED_ERROR,
+                        ETC_OUTPUT_EXPECTED_ERROR_COLOR,
                         curr_expected_line,
-                        ETC_OUTPUT_RESET,
+                        ETC_OUTPUT_RESET_COLOR,
                     )
                     curr_actual_line = ''
                 else:
@@ -349,8 +349,8 @@ class CoreTestCaseMixin:
                         max_chars = len(curr_expected_line)
 
                     # Check each character and determine where non-match happens.
-                    curr_expected_color = ETC_OUTPUT_RESET
-                    curr_actual_color = ETC_OUTPUT_RESET
+                    curr_expected_color = ETC_OUTPUT_RESET_COLOR
+                    curr_actual_color = ETC_OUTPUT_RESET_COLOR
                     curr_expected_char_line = ''
                     curr_actual_char_line = ''
                     for char_index in range(max_chars):
@@ -367,19 +367,19 @@ class CoreTestCaseMixin:
                         # Format based on match.
                         if expected_char == actual_char:
                             # Match.
-                            if curr_expected_color != ETC_OUTPUT_EXPECTED_MATCH:
-                                curr_expected_color = ETC_OUTPUT_EXPECTED_MATCH
+                            if curr_expected_color != ETC_OUTPUT_EXPECTED_MATCH_COLOR:
+                                curr_expected_color = ETC_OUTPUT_EXPECTED_MATCH_COLOR
                                 curr_expected_char_line += curr_expected_color
-                            if curr_actual_color != ETC_OUTPUT_ACTUALS_MATCH:
-                                curr_actual_color = ETC_OUTPUT_ACTUALS_MATCH
+                            if curr_actual_color != ETC_OUTPUT_ACTUALS_MATCH_COLOR:
+                                curr_actual_color = ETC_OUTPUT_ACTUALS_MATCH_COLOR
                                 curr_actual_char_line += curr_actual_color
                         else:
                             # Non-match.
-                            if curr_expected_color != ETC_OUTPUT_EXPECTED_ERROR:
-                                curr_expected_color = ETC_OUTPUT_EXPECTED_ERROR
+                            if curr_expected_color != ETC_OUTPUT_EXPECTED_ERROR_COLOR:
+                                curr_expected_color = ETC_OUTPUT_EXPECTED_ERROR_COLOR
                                 curr_expected_char_line += curr_expected_color
-                            if curr_actual_color != ETC_OUTPUT_ACTUALS_ERROR:
-                                curr_actual_color = ETC_OUTPUT_ACTUALS_ERROR
+                            if curr_actual_color != ETC_OUTPUT_ACTUALS_ERROR_COLOR:
+                                curr_actual_color = ETC_OUTPUT_ACTUALS_ERROR_COLOR
                                 curr_actual_char_line += curr_actual_color
 
                         curr_expected_char_line += '{0}'.format(expected_char)
@@ -398,11 +398,11 @@ class CoreTestCaseMixin:
             # Finally print actual debug output.
             self._debug_print('')
             self._debug_print('')
-            self._debug_print('EXPECTED:', fore=ETC_OUTPUT_EXPECTED_MATCH)
+            self._debug_print('EXPECTED:', fore=ETC_OUTPUT_EXPECTED_MATCH_COLOR)
             self._debug_print(formatted_expected_output)
             self._debug_print('')
             self._debug_print('')
-            self._debug_print('ACTUAL:', fore=ETC_OUTPUT_ACTUALS_MATCH)
+            self._debug_print('ACTUAL:', fore=ETC_OUTPUT_ACTUALS_MATCH_COLOR)
             self._debug_print(formatted_actual_output)
             self._debug_print('')
             self._debug_print('')
diff --git a/django_expanded_test_cases/mixins/response_mixin.py b/django_expanded_test_cases/mixins/response_mixin.py
index acddf231689b5604b5c1fef6d8dd95254f2d720f..dbb3f7b21598259509aa2f5a62d505b05e2a318c 100644
--- a/django_expanded_test_cases/mixins/response_mixin.py
+++ b/django_expanded_test_cases/mixins/response_mixin.py
@@ -13,15 +13,15 @@ from django.http.response import HttpResponseBase
 # Internal Imports.
 from . import CoreTestCaseMixin
 from django_expanded_test_cases.constants import (
-    ETC_OUTPUT_ERROR,
+    ETC_OUTPUT_ERROR_COLOR,
     ETC_RESPONSE_DEBUG_CONTENT_COLOR,
-    ETC_RESPONSE_DEBUG_HEADERS_COLOR,
+    ETC_RESPONSE_DEBUG_HEADER_COLOR,
     ETC_RESPONSE_DEBUG_CONTEXT_COLOR,
     ETC_RESPONSE_DEBUG_MESSAGE_COLOR,
     ETC_RESPONSE_DEBUG_SESSION_COLOR,
     ETC_RESPONSE_DEBUG_FORM_COLOR,
     ETC_RESPONSE_DEBUG_USER_INFO_COLOR,
-    ETC_OUTPUT_EMPHASIS,
+    ETC_OUTPUT_EMPHASIS_COLOR,
 )
 
 
@@ -65,7 +65,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'response.content'),
             fore=ETC_RESPONSE_DEBUG_CONTENT_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         # Print out data, if present.
@@ -91,14 +91,14 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print()
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'response.headers'),
-            fore=ETC_RESPONSE_DEBUG_HEADERS_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            fore=ETC_RESPONSE_DEBUG_HEADER_COLOR,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         # Print out data, if present.
         if response_headers is not None and len(response_headers) > 0:
             for key, value in response_headers.items():
-                self._debug_print('    * "{0}": "{1}"'.format(key, value), fore=ETC_RESPONSE_DEBUG_HEADERS_COLOR)
+                self._debug_print('    * "{0}": "{1}"'.format(key, value), fore=ETC_RESPONSE_DEBUG_HEADER_COLOR)
         else:
             self._debug_print('    No response headers found.')
         self._debug_print()
@@ -129,7 +129,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'response.context'),
             fore=ETC_RESPONSE_DEBUG_CONTEXT_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         # NOTE: Response context object is strange, in that it's basically a dictionary,
@@ -157,7 +157,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'client.session'),
             fore=ETC_RESPONSE_DEBUG_SESSION_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         if client is not None and len(client.session.items()) > 0:
@@ -178,7 +178,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'response.context["messages"]'),
             fore=ETC_RESPONSE_DEBUG_MESSAGE_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         # Print out data, if present.
@@ -204,7 +204,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'Form Data'),
             fore=ETC_RESPONSE_DEBUG_FORM_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         # Check if form or formset data is actually present.
@@ -272,7 +272,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
         self._debug_print(
             '{0} {1} {0}'.format('=' * 10, 'User Info'),
             fore=ETC_RESPONSE_DEBUG_USER_INFO_COLOR,
-            style=ETC_OUTPUT_EMPHASIS,
+            style=ETC_OUTPUT_EMPHASIS_COLOR,
         )
 
         # Only proceed if we got a proper user model.
@@ -309,7 +309,7 @@ class ResponseTestCaseMixin(CoreTestCaseMixin):
                 user,
                 type(user),
                 type(get_user_model()),
-            ), fore=ETC_OUTPUT_ERROR)
+            ), fore=ETC_OUTPUT_ERROR_COLOR)
         self._debug_print()
         self._debug_print()
 
diff --git a/django_expanded_test_cases/test_cases/base_test_case.py b/django_expanded_test_cases/test_cases/base_test_case.py
index 672a3b23f402a3fe7d5ca2810753752785bb505a..49ac9250d2bc6183987608e44933db5e9aef17a9 100644
--- a/django_expanded_test_cases/test_cases/base_test_case.py
+++ b/django_expanded_test_cases/test_cases/base_test_case.py
@@ -6,7 +6,7 @@ Testing class for generalized logic.
 from django.test import TestCase
 
 # Internal Imports.
-from django_expanded_test_cases.constants import ETC_OUTPUT_EMPHASIS, ETC_OUTPUT_ERROR
+from django_expanded_test_cases.constants import ETC_OUTPUT_EMPHASIS_COLOR, ETC_OUTPUT_ERROR_COLOR
 from django_expanded_test_cases.mixins import CoreTestCaseMixin
 
 
@@ -59,8 +59,8 @@ class BaseTestCase(TestCase, CoreTestCaseMixin):
                     self.__class__.__name__,
                     type(err).__name__,
                 ),
-                fore=ETC_OUTPUT_ERROR,
-                style=ETC_OUTPUT_EMPHASIS,
+                fore=ETC_OUTPUT_ERROR_COLOR,
+                style=ETC_OUTPUT_EMPHASIS_COLOR,
             )
             self._debug_print('{0}\n\n'.format(str(err)))
 
diff --git a/django_expanded_test_cases/test_cases/integration_test_case.py b/django_expanded_test_cases/test_cases/integration_test_case.py
index 72374938ed9893081b35a9debabbab9afb5bbc74..6835df5cd0600acb9eda255fd0984e3cad79b688 100644
--- a/django_expanded_test_cases/test_cases/integration_test_case.py
+++ b/django_expanded_test_cases/test_cases/integration_test_case.py
@@ -18,7 +18,7 @@ from django_expanded_test_cases.constants import (
     ETC_INCLUDE_RESPONSE_DEBUG_CONTENT,
     ETC_INCLUDE_RESPONSE_DEBUG_CONTEXT,
     ETC_INCLUDE_RESPONSE_DEBUG_FORMS,
-    ETC_INCLUDE_RESPONSE_DEBUG_HEADERS,
+    ETC_INCLUDE_RESPONSE_DEBUG_HEADER,
     ETC_INCLUDE_RESPONSE_DEBUG_MESSAGES,
     ETC_INCLUDE_RESPONSE_DEBUG_SESSION,
     ETC_INCLUDE_RESPONSE_DEBUG_URL,
@@ -27,7 +27,7 @@ from django_expanded_test_cases.constants import (
     ETC_REQUEST_USER_STRICTNESS,
     ETC_DEFAULT_STANDARD_USER_IDENTIFIER,
     ETC_RESPONSE_DEBUG_URL_COLOR,
-    ETC_OUTPUT_EMPHASIS,
+    ETC_OUTPUT_EMPHASIS_COLOR,
     VOID_ELEMENT_LIST,
 )
 from django_expanded_test_cases.mixins import ResponseTestCaseMixin
@@ -114,7 +114,7 @@ class IntegrationTestCase(BaseTestCase, ResponseTestCaseMixin):
         if self._debug_print_bool:
             if ETC_INCLUDE_RESPONSE_DEBUG_CONTENT:
                 self.show_debug_content(response)
-            if ETC_INCLUDE_RESPONSE_DEBUG_HEADERS:
+            if ETC_INCLUDE_RESPONSE_DEBUG_HEADER:
                 self.show_debug_headers(response)
             if ETC_INCLUDE_RESPONSE_DEBUG_CONTEXT:
                 self.show_debug_context(response)
@@ -898,9 +898,9 @@ class IntegrationTestCase(BaseTestCase, ResponseTestCaseMixin):
 
         self._debug_print('\n\n')
         if ETC_INCLUDE_RESPONSE_DEBUG_URL:
-            self._debug_print('{0}'.format('-' * len(message)), fore=ETC_RESPONSE_DEBUG_URL_COLOR, style=ETC_OUTPUT_EMPHASIS)
-            self._debug_print(message, fore=ETC_RESPONSE_DEBUG_URL_COLOR, style=ETC_OUTPUT_EMPHASIS)
-            self._debug_print('{0}'.format('-' * len(message)), fore=ETC_RESPONSE_DEBUG_URL_COLOR, style=ETC_OUTPUT_EMPHASIS)
+            self._debug_print('{0}'.format('-' * len(message)), fore=ETC_RESPONSE_DEBUG_URL_COLOR, style=ETC_OUTPUT_EMPHASIS_COLOR)
+            self._debug_print(message, fore=ETC_RESPONSE_DEBUG_URL_COLOR, style=ETC_OUTPUT_EMPHASIS_COLOR)
+            self._debug_print('{0}'.format('-' * len(message)), fore=ETC_RESPONSE_DEBUG_URL_COLOR, style=ETC_OUTPUT_EMPHASIS_COLOR)
 
         # Get response object.
         if bool(get):
diff --git a/tests/test_cases/test_base_case.py b/tests/test_cases/test_base_case.py
index 2c1b0710453d250b0c3daee0e5811d96f98e2997..17cdcd2f4a2818395d60f72df8d1f6cf58eb6d12 100644
--- a/tests/test_cases/test_base_case.py
+++ b/tests/test_cases/test_base_case.py
@@ -15,11 +15,11 @@ from django.test import override_settings
 # Internal Imports.
 from django_expanded_test_cases import BaseTestCase
 from django_expanded_test_cases.constants import (
-    ETC_OUTPUT_ACTUALS_MATCH,
-    ETC_OUTPUT_ACTUALS_ERROR,
-    ETC_OUTPUT_EXPECTED_MATCH,
-    ETC_OUTPUT_EXPECTED_ERROR,
-    ETC_OUTPUT_RESET,
+    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+    ETC_OUTPUT_RESET_COLOR,
 )
 
 
@@ -215,21 +215,21 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[5], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[5], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Actuals has values here. Expected does not.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Actuals has values here. Expected does not.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[13], '')
 
         with self.subTest('With actuals as empty'):
@@ -241,21 +241,21 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Expected has values here. Actuals does not.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
-            )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[9], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET)
+                '{0}Expected has values here. Actuals does not.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
+            )
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[9], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[13], '')
 
         with self.subTest('With expected as empty and actuals as multi-line'):
@@ -267,22 +267,22 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[5], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[5], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Actuals has values here.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Actuals has values here.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], '{0}Expected does not.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], '{0}Expected does not.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[14], '')
 
         with self.subTest('With actuals as empty and expected as multi-line'):
@@ -294,22 +294,22 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Expected has values here.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
-            )
-            self.assertEqual(std_out_lines[6], '{0}Actuals does not.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[9], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[10], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET)
+                '{0}Expected has values here.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
+            )
+            self.assertEqual(std_out_lines[6], '{0}Actuals does not.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[9], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[10], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[14], '')
 
         with self.subTest('With expected as one line less - At end'):
@@ -323,20 +323,20 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[5], '{0}One line.{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[9], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[10], '{0}One line.{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[11], '{0}Two line.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[14], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[5], '{0}One line.{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[9], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[10], '{0}One line.{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[11], '{0}Two line.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[14], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[15], '')
 
         with self.subTest('With actuals as one line less - At end'):
@@ -348,20 +348,20 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[5], '{0}One line.{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[6], '{0}Two line.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[9], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[10], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[11], '{0}One line.{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
-            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[14], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[5], '{0}One line.{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[6], '{0}Two line.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[9], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[10], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[11], '{0}One line.{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
+            self.assertEqual(std_out_lines[12], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[13], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[14], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[15], '')
 
     def test__assertText_coloring__missing_characters(self):
@@ -379,23 +379,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}esting.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}esting.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Testing.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With actuals as one char missing - At start'):
@@ -407,23 +407,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Testing.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}esting.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}esting.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With expected as multiple characters missing - At start'):
@@ -435,23 +435,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}sting.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}sting.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Testing.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With actuals as multiple characters missing - At start'):
@@ -463,23 +463,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Testing.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing.{1}'.format(ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}sting.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}sting.{1}'.format(ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With expected as one char missing - At middle'):
@@ -491,23 +491,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Tes{1}ing.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Tes{1}ing.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Tes{1}ting.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Tes{1}ting.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With actuals as one char missing - At middle'):
@@ -519,23 +519,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Tes{1}ting.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Tes{1}ting.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Tes{1}ing.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Tes{1}ing.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With expected as multiple characters missing - At middle'):
@@ -547,23 +547,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Te{1}ng.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Te{1}ng.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Te{1}sting.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Te{1}sting.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With actuals as multiple characters missing - At middle'):
@@ -575,23 +575,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Te{1}sting.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Te{1}sting.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Te{1}ng.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Te{1}ng.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With expected as one char missing - At end'):
@@ -603,23 +603,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Testing{1}{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing{1}{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Testing{1}.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing{1}.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With actuals as one char missing - At end'):
@@ -631,23 +631,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Testing{1}.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing{1}.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Testing{1}{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Testing{1}{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With expected as multiple characters missing - At end'):
@@ -659,23 +659,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Test{1}{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Test{1}{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Test{1}ing.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Test{1}ing.{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With actuals as multiple characters missing - At end'):
@@ -687,23 +687,23 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
-                '{0}Test{1}ing.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_EXPECTED_ERROR, ETC_OUTPUT_RESET),
+                '{0}Test{1}ing.{2}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_EXPECTED_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
-                '{0}Test{1}{2}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_ACTUALS_ERROR, ETC_OUTPUT_RESET),
+                '{0}Test{1}{2}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_ACTUALS_ERROR_COLOR, ETC_OUTPUT_RESET_COLOR),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
     def test__assertText_coloring__wrong_characters(self):
@@ -720,31 +720,31 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
                 '{0}a{1}BC{2}'.format(
-                    ETC_OUTPUT_EXPECTED_ERROR,
-                    ETC_OUTPUT_EXPECTED_MATCH,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+                    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
                 '{0}A{1}BC{2}'.format(
-                    ETC_OUTPUT_ACTUALS_ERROR,
-                    ETC_OUTPUT_ACTUALS_MATCH,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+                    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With wrong characters at start - Larger str'):
@@ -756,31 +756,31 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
                 '{0}tHIS{1} is a test value.{2}'.format(
-                    ETC_OUTPUT_EXPECTED_ERROR,
-                    ETC_OUTPUT_EXPECTED_MATCH,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+                    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
                 '{0}This{1} is a test value.{2}'.format(
-                    ETC_OUTPUT_ACTUALS_ERROR,
-                    ETC_OUTPUT_ACTUALS_MATCH,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+                    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With wrong character at middle - Small str'):
@@ -792,31 +792,31 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
                 '{0}A{1}b{0}C{2}'.format(
-                    ETC_OUTPUT_EXPECTED_MATCH,
-                    ETC_OUTPUT_EXPECTED_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+                    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
                 '{0}A{1}B{0}C{2}'.format(
-                    ETC_OUTPUT_ACTUALS_MATCH,
-                    ETC_OUTPUT_ACTUALS_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+                    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With wrong character at middle - Larger str'):
@@ -828,31 +828,31 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
                 '{0}This {1}IS{0} {1}A{0} {1}TEST{0} value.{2}'.format(
-                    ETC_OUTPUT_EXPECTED_MATCH,
-                    ETC_OUTPUT_EXPECTED_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+                    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
                 '{0}This {1}is{0} {1}a{0} {1}test{0} value.{2}'.format(
-                    ETC_OUTPUT_ACTUALS_MATCH,
-                    ETC_OUTPUT_ACTUALS_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+                    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With wrong character at end - Small str'):
@@ -864,31 +864,31 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
                 '{0}AB{1}c{2}'.format(
-                    ETC_OUTPUT_EXPECTED_MATCH,
-                    ETC_OUTPUT_EXPECTED_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+                    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
                 '{0}AB{1}C{2}'.format(
-                    ETC_OUTPUT_ACTUALS_MATCH,
-                    ETC_OUTPUT_ACTUALS_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+                    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
         with self.subTest('With wrong characters at end - Larger str'):
@@ -900,31 +900,31 @@ class BaseClassTest(BaseTestCase):
 
             # Test all line values.
             self.assertEqual(std_out_lines[0], '')
-            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[1], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[2], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[3], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[4], '{0}EXPECTED:{1}'.format(ETC_OUTPUT_EXPECTED_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[5],
                 '{0}This is a test {1}VALUE!{2}'.format(
-                    ETC_OUTPUT_EXPECTED_MATCH,
-                    ETC_OUTPUT_EXPECTED_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_EXPECTED_MATCH_COLOR,
+                    ETC_OUTPUT_EXPECTED_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH, ETC_OUTPUT_RESET))
+            self.assertEqual(std_out_lines[6], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[7], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[8], '{0}ACTUAL:{1}'.format(ETC_OUTPUT_ACTUALS_MATCH_COLOR, ETC_OUTPUT_RESET_COLOR))
             self.assertEqual(
                 std_out_lines[9],
                 '{0}This is a test {1}value.{2}'.format(
-                    ETC_OUTPUT_ACTUALS_MATCH,
-                    ETC_OUTPUT_ACTUALS_ERROR,
-                    ETC_OUTPUT_RESET,
+                    ETC_OUTPUT_ACTUALS_MATCH_COLOR,
+                    ETC_OUTPUT_ACTUALS_ERROR_COLOR,
+                    ETC_OUTPUT_RESET_COLOR,
                 ),
             )
-            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET)
-            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET)
+            self.assertEqual(std_out_lines[10], ETC_OUTPUT_RESET_COLOR)
+            self.assertEqual(std_out_lines[11], ETC_OUTPUT_RESET_COLOR)
             self.assertEqual(std_out_lines[12], '')
 
     # endregion Assertion Tests