diff --git a/email2pdf b/email2pdf
index 8309b1a..b61b86a 100755
--- a/email2pdf
+++ b/email2pdf
@@ -84,6 +84,14 @@ def main(argv, syslog_handler, syserr_handler):
     output_file_name = get_output_file_name(args, output_directory)
     logger.info("Output file name is: " + output_file_name)
 
+    (warning_logger_name, _) = os.path.splitext(output_file_name)
+    warning_logger_name = os.path.join(os.path.dirname(warning_logger_name),
+                                       os.path.basename(warning_logger_name) + "_warnings_and_errors.txt")
+    warning_logger = logging.FileHandler(warning_logger_name, delay=True)
+    warning_logger.setLevel(logging.WARNING)
+    warning_logger.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
+    logger.addHandler(warning_logger)
+
     input_data = get_input_data(args)
     logger.debug("Email input data is: " + input_data)
 
diff --git a/tests/BaseTestClasses.py b/tests/BaseTestClasses.py
index 88f09ea..7c09464 100644
--- a/tests/BaseTestClasses.py
+++ b/tests/BaseTestClasses.py
@@ -66,12 +66,23 @@ class Email2PDFTestCase(unittest.TestCase):
         else:
             return False
 
-    def getTimedFilename(self, path=None):
+    def existsByTimeWarning(self):
+        if self.getTimedFilename(postfix="_warnings_and_errors.txt"):
+            return True
+        else:
+            return False
+
+    def getWarningFileContents(self):
+        filename = self.getTimedFilename(postfix="_warnings_and_errors.txt")
+        with open(filename) as f:
+            return f.read()
+
+    def getTimedFilename(self, path=None, postfix=".pdf"):
         if path is None:
             path = self.workingDir
 
         for single_time in self._timerange(self.time_invoked, self.time_completed):
-            filename = os.path.join(path, self.getTimeStamp(single_time) + ".pdf")
+            filename = os.path.join(path, self.getTimeStamp(single_time) + postfix)
             if os.path.exists(filename):
                 return filename
 
@@ -180,20 +191,22 @@ class Email2PDFTestCase(unittest.TestCase):
             options.extend(extraParams)
 
             stream = io.StringIO()
-            handler = logging.StreamHandler(stream)
+            stream_handler = logging.StreamHandler(stream)
             log = logging.getLogger('email2pdf')
             log.propagate = False
             log.setLevel(logging.DEBUG)
-            log.addHandler(handler)
+            log.addHandler(stream_handler)
 
             self.time_invoked = datetime.now()
 
             try:
-                email2pdf.main(options, None, handler)
+                email2pdf.main(options, None, stream_handler)
             finally:
                 self.time_completed = datetime.now()
-                log.removeHandler(handler)
-                handler.close()
+                for handler in log.handlers:
+                    handler.close()
+                    log.removeHandler(handler)
+                stream_handler.close()
 
             error = stream.getvalue()
 
diff --git a/tests/Direct/test_Direct_Arguments.py b/tests/Direct/test_Direct_Arguments.py
index 3135c4b..08a37b9 100644
--- a/tests/Direct/test_Direct_Arguments.py
+++ b/tests/Direct/test_Direct_Arguments.py
@@ -15,6 +15,8 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(extraParams=['--no-body'])
         self.assertFalse(self.existsByTime())
         self.assertRegex(error, "body.*any.*attachments")
+        self.assertTrue(self.existsByTimeWarning())
+        self.assertRegex(self.getWarningFileContents(), "body.*any.*attachments")
 
     def test_no_attachments(self):
         self.addHeaders()
@@ -29,6 +31,7 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, filename2)))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, filename3)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_no_body_and_no_attachments(self):
         self.addHeaders()
@@ -39,6 +42,7 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         with self.assertRaisesRegex(Exception, "attachments.*not allowed with.*body"):
             self.invokeDirectly(extraParams=['--no-body', '--no-attachments'])
         self.assertFalse(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_headers(self):
         path = os.path.join(self.examineDir, "headers.pdf")
@@ -52,6 +56,7 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         self.assertRegex(pdf_text, "From")
         self.assertRegex(pdf_text, "To")
         self.assertRegex(pdf_text, "Hello")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_add_prefix_date(self):
         self.addHeaders()
@@ -77,6 +82,7 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename4)), "Some PDF content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir,
                                                       datetime.now().strftime("%Y-%m-%d-") + filename)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_verbose(self):
         self.attachText("Hello!")
@@ -84,6 +90,7 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         self.assertNotEqual('', error)
         self.assertTrue(self.existsByTime())
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_veryverbose(self):
         self.attachText("Hello!")
@@ -91,3 +98,4 @@ class Direct_Arguments(BaseTestClasses.Email2PDFTestCase):
         self.assertNotEqual('', error)
         self.assertTrue(self.existsByTime())
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Direct/test_Direct_AttachmentDetection.py b/tests/Direct/test_Direct_AttachmentDetection.py
index a4d3f6c..f42eb81 100644
--- a/tests/Direct/test_Direct_AttachmentDetection.py
+++ b/tests/Direct/test_Direct_AttachmentDetection.py
@@ -20,6 +20,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_pdf_with_invalid_extension(self):
         self.addHeaders()
@@ -31,6 +32,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_pdf_as_octet_stream_with_invalid_extension(self):
         self.addHeaders()
@@ -42,6 +44,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_pdf_as_octet_stream_no_body(self):
         self.addHeaders()
@@ -52,6 +55,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertFalse(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_jpeg_as_octet_stream(self):
         self.addHeaders()
@@ -63,6 +67,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, image_filename)))
         self.assertIsJPG(os.path.join(self.workingDir, image_filename))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_jpeg_with_invalid_extension(self):
         self.addHeaders()
@@ -74,6 +79,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, image_filename)))
         self.assertIsJPG(os.path.join(self.workingDir, image_filename))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_jpeg_as_octet_stream_with_invalid_extension(self):
         self.addHeaders()
@@ -85,6 +91,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, image_filename)))
         self.assertIsJPG(os.path.join(self.workingDir, image_filename))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_word_document(self):
         self.addHeaders()
@@ -96,6 +103,7 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, "somefile.docx")))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_unidentified_file(self):
         self.addHeaders()
@@ -106,3 +114,4 @@ class AttachmentDetection(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, "somefile.xyz")))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Direct/test_Direct_Basic.py b/tests/Direct/test_Direct_Basic.py
index 6051368..98489ee 100644
--- a/tests/Direct/test_Direct_Basic.py
+++ b/tests/Direct/test_Direct_Basic.py
@@ -16,6 +16,7 @@ class Direct_Basic(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly()
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_internationalised_subject(self):
         path = os.path.join(self.examineDir, "internationalised_subject.pdf")
@@ -23,6 +24,7 @@ class Direct_Basic(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path, extraParams=['--headers'])
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_internationalised_subject2(self):
         path = os.path.join(self.examineDir, "internationalised_subject_jp.pdf")
@@ -30,6 +32,7 @@ class Direct_Basic(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path, extraParams=['--headers'])
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_internationalised_subject3(self):
         path = os.path.join(self.examineDir, "internationalised_subject_de.pdf")
@@ -37,6 +40,7 @@ class Direct_Basic(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path, extraParams=['--headers'])
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_internationalised_subject4(self):
         path = os.path.join(self.examineDir, "internationalised_subject_complex.pdf")
@@ -48,3 +52,4 @@ class Direct_Basic(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path, extraParams=['--headers'])
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Direct/test_Direct_CID.py b/tests/Direct/test_Direct_CID.py
index 5acde29..a767c36 100644
--- a/tests/Direct/test_Direct_CID.py
+++ b/tests/Direct/test_Direct_CID.py
@@ -18,6 +18,8 @@ class Direct_CID(Email2PDFTestCase):
         self.assertFalse(self.existsByTime())
         self.assertRegex(error, "body.*any.*attachments")
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'myid.jpg')))
+        self.assertTrue(self.existsByTimeWarning())
+        self.assertRegex(self.getWarningFileContents(), "body.*any.*attachments")
 
     def test_inline_image_with_filename_no_body(self):
         self.addHeaders()
@@ -27,6 +29,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertFalse(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_inline_image_and_pdf(self):
         self.addHeaders()
@@ -38,6 +41,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertFalse(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, pdf_file_name)))
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, pdf_file_name)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image(self):
         path = os.path.join(self.examineDir, "embeddedImage.pdf")
@@ -49,6 +53,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(os.path.exists(path))
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(path))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image_with_complex_name(self):
         path = os.path.join(self.examineDir, "embeddedImageWithComplexName.pdf")
@@ -60,6 +65,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(os.path.exists(path))
         self.assertLess(Email2PDFTestCase.PNG_SIZE, os.path.getsize(path))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image_invalid_cid(self):
         self.addHeaders()
@@ -70,6 +76,8 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertGreater(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertTrue(self.existsByTimeWarning())
+        self.assertRegex(self.getWarningFileContents(), "(?i)could not find image")
 
     def test_embedded_image_png(self):
         path = os.path.join(self.examineDir, "embeddedImagePNG.pdf")
@@ -81,6 +89,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(os.path.exists(path))
         self.assertLess(Email2PDFTestCase.PNG_SIZE, os.path.getsize(path))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image_cid_underscore(self):
         self.addHeaders()
@@ -91,6 +100,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image_extra_html_content(self):
         if self.isOnline:
@@ -103,6 +113,7 @@ class Direct_CID(Email2PDFTestCase):
             self.assertTrue(self.existsByTime())
             self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
             self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+            self.assertFalse(self.existsByTimeWarning())
         else:
             self.skipTest("Not online.")
 
@@ -115,6 +126,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image_no_attachments(self):
         self.addHeaders()
@@ -125,6 +137,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_embedded_image_as_octet_stream(self):
         self.addHeaders()
@@ -135,6 +148,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_one_embedded_one_not_image(self):
         self.addHeaders()
@@ -147,6 +161,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, image_filename2)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_two_embedded(self):
         path = os.path.join(self.examineDir, "twoEmbeddedImages.pdf")
@@ -158,6 +173,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(os.path.exists(path))
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(path))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_two_different_embedded(self):
         path = os.path.join(self.examineDir, "twoDifferentEmbeddedImages.pdf")
@@ -171,6 +187,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertLess(Email2PDFTestCase.JPG_SIZE + Email2PDFTestCase.PNG_SIZE, os.path.getsize(path))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename)))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, image_filename2)))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_some_cids_not_referenced(self):
         self.addHeaders()
@@ -189,6 +206,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'myid3.jpg')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'floating_attachment.jpg')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'floating_attachment_1.jpg')))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_some_cids_not_referenced_ignore_floating_attachments(self):
         self.addHeaders()
@@ -207,6 +225,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'myid3.jpg')))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'floating_attachment.jpg')))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'floating_attachment_1.jpg')))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_some_cids_not_referenced_png(self):
         self.addHeaders()
@@ -221,6 +240,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'myid.png')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'myid2.png')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'floating_attachment.png')))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_some_cids_not_referenced_pdf(self):
         self.addHeaders()
@@ -234,6 +254,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'myid.png')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'floating_attachment.pdf')))
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, 'floating_attachment.pdf')), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_some_cids_not_referenced_docx(self):
         self.addHeaders()
@@ -248,6 +269,7 @@ class Direct_CID(Email2PDFTestCase):
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'myid.png')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'floating_attachment.docx')))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_some_cids_not_referenced_misc(self):
         self.addHeaders()
@@ -262,3 +284,4 @@ class Direct_CID(Email2PDFTestCase):
         self.assertLess(Email2PDFTestCase.JPG_SIZE, os.path.getsize(self.getTimedFilename()))
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'myid.png')))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'floating_attachment')))
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Direct/test_Direct_Errors.py b/tests/Direct/test_Direct_Errors.py
index 477cd03..a54e11f 100644
--- a/tests/Direct/test_Direct_Errors.py
+++ b/tests/Direct/test_Direct_Errors.py
@@ -16,11 +16,13 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         with tempfile.NamedTemporaryFile() as tmpfile:
             with self.assertRaisesRegex(Exception, "file.*exist"):
                 self.invokeDirectly(outputFile=tmpfile.name, okToExist=True)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_dirnotexist(self):
         self.attachText("Hello!")
         with self.assertRaisesRegex(Exception, "(?i)directory.*not.*exist"):
             self.invokeDirectly(outputDirectory="/notexist/")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_image_doesnt_exist(self):
         if self.isOnline:
@@ -30,6 +32,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
             error = self.invokeDirectly(outputFile=path)
             self.assertTrue(os.path.exists(path))
             self.assertRegex(error, "(?i)could not retrieve")
+            self.assertFalse(self.existsByTimeWarning())
         else:
             self.skipTest("Not online.")
 
@@ -40,6 +43,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_image_doesnt_exist_blacklist_upper(self):
         path = os.path.join(self.examineDir, "remoteImageDoesntExistBlacklistUpper.pdf")
@@ -48,6 +52,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_image_doesnt_exist_with_pdf(self):
         if self.isOnline:
@@ -58,6 +63,8 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
             self.assertTrue(self.existsByTime())
             self.assertTrue(os.path.exists(os.path.join(self.workingDir, filename)))
             self.assertRegex(error, "(?i)could not retrieve")
+            self.assertTrue(self.existsByTimeWarning())
+            self.assertRegex(self.getWarningFileContents(), "(?i)could not retrieve")
         else:
             self.skipTest("Not online.")
 
@@ -68,6 +75,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(error, "(?i)could not retrieve")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_local_image_with_query_doesnt_exist(self):
         path = os.path.join(self.examineDir, "localImageWithQueryDoesntExist.pdf")
@@ -76,6 +84,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(error, "(?i)could not retrieve")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_local_script_doesnt_exist(self):
         path = os.path.join(self.examineDir, "localScriptDoesntExist.pdf")
@@ -84,6 +93,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_local_script_with_query_doesnt_exist(self):
         path = os.path.join(self.examineDir, "localScriptWithQueryDoesntExist.pdf")
@@ -92,6 +102,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_local_stylesheet_doesnt_exist(self):
         path = os.path.join(self.examineDir, "localStylesheetDoesntExist.pdf")
@@ -100,6 +111,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_local_stylesheet_with_query_doesnt_exist(self):
         path = os.path.join(self.examineDir, "localStylesheetWithQueryDoesntExist.pdf")
@@ -108,6 +120,7 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly(outputFile=path)
         self.assertTrue(os.path.exists(path))
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_no_explicit_parts(self):
         # If we don't add any parts explicitly, email2pdf should find a
@@ -115,11 +128,13 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly()
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_fuzz(self):
         with self.assertRaisesRegex(Exception, "(?i)defects parsing email"):
             self.invokeDirectly(completeMessage="This is total junk")
         self.assertFalse(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_broken_html(self):
         self.addHeaders()
@@ -127,3 +142,4 @@ class Direct_Errors(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly()
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Direct/test_Direct_FrozenTime.py b/tests/Direct/test_Direct_FrozenTime.py
index 750d7b4..4eb48fe 100644
--- a/tests/Direct/test_Direct_FrozenTime.py
+++ b/tests/Direct/test_Direct_FrozenTime.py
@@ -18,6 +18,7 @@ class Direct_Complex(BaseTestClasses.Email2PDFTestCase):
         error = self.invokeDirectly()
         self.assertEqual('', error)
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, "2016-08-09T23-04-05.pdf")))
+        self.assertFalse(self.existsByTimeWarning())
 
     @freeze_time("2017-09-11 00:05:06")
     def test_add_prefix_date(self):
@@ -31,6 +32,7 @@ class Direct_Complex(BaseTestClasses.Email2PDFTestCase):
         self.assertFalse(os.path.exists(os.path.join(self.workingDir, filename)))
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, "2017-09-11-" + filename)))
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, "2017-09-11-" + filename)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     @freeze_time("2015-02-03 14:00:00")
     def test_plaincontent_timedfileexist(self):
@@ -46,3 +48,4 @@ class Direct_Complex(BaseTestClasses.Email2PDFTestCase):
         self.assertTrue(os.path.exists(filename2))
         self.assertIsNone(self.getPDFText(filename1))
         self.assertRegex(self.getPDFText(filename2), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Direct/test_Direct_Metadata.py b/tests/Direct/test_Direct_Metadata.py
index 7f941ed..964bff6 100644
--- a/tests/Direct/test_Direct_Metadata.py
+++ b/tests/Direct/test_Direct_Metadata.py
@@ -21,6 +21,7 @@ class Direct_Metadata(Email2PDFTestCase):
         self.assertEqual(Email2PDFTestCase.DEFAULT_TO, self.getMetadataField(timedFilename, "X-email2pdf-To"))
         self.assertEqual(Email2PDFTestCase.DEFAULT_SUBJECT, self.getMetadataField(timedFilename, "Title"))
         self.assertEqual("email2pdf", self.getMetadataField(timedFilename, "Producer"))
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_metadata(self):
         self.addHeaders()
@@ -34,6 +35,7 @@ class Direct_Metadata(Email2PDFTestCase):
         self.assertEqual(Email2PDFTestCase.DEFAULT_SUBJECT, self.getMetadataField(path, "Title"))
         self.assertEqual("email2pdf", self.getMetadataField(path, "Producer"))
         self.assertRegex(self.getPDFText(path), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_metadata_differentmount(self):
         self.addHeaders()
@@ -48,6 +50,7 @@ class Direct_Metadata(Email2PDFTestCase):
                 self.assertEqual(Email2PDFTestCase.DEFAULT_TO, self.getMetadataField(path, "X-email2pdf-To"))
                 self.assertEqual(Email2PDFTestCase.DEFAULT_SUBJECT, self.getMetadataField(path, "Title"))
                 self.assertEqual("email2pdf", self.getMetadataField(path, "Producer"))
+                self.assertFalse(self.existsByTimeWarning())
             else:
                 self.skipTest(tempdir + " and " + tempfile.tempdir + " are on the same mountpoint, test not relevant.")
 
@@ -62,6 +65,7 @@ class Direct_Metadata(Email2PDFTestCase):
         self.assertEqual('', self.getMetadataField(path, "Title"))
         self.assertEqual("email2pdf", self.getMetadataField(path, "Producer"))
         self.assertRegex(self.getPDFText(path), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_metadata_internationalised_subject(self):
         self.addHeaders(subject=bytes("Hello!", 'iso-8859-1'), subject_encoding='iso-8859-1')
@@ -73,3 +77,4 @@ class Direct_Metadata(Email2PDFTestCase):
         self.assertEqual(Email2PDFTestCase.DEFAULT_TO, self.getMetadataField(timedFilename, "X-email2pdf-To"))
         self.assertEqual("Hello!", self.getMetadataField(timedFilename, "Title"))
         self.assertEqual("email2pdf", self.getMetadataField(timedFilename, "Producer"))
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Subprocess/test_Subprocess_Basic.py b/tests/Subprocess/test_Subprocess_Basic.py
index c484837..f8b93bb 100644
--- a/tests/Subprocess/test_Subprocess_Basic.py
+++ b/tests/Subprocess/test_Subprocess_Basic.py
@@ -17,29 +17,35 @@ class TestBasic(Email2PDFTestCase):
         self.assertEqual(0, rc)
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_help(self):
         (rc, output, error) = self.invokeAsSubprocess(extraParams=['--help'], expectOutput=True)
         self.assertEqual(0, rc)
         self.assertRegex(output, 'usage:')
         self.assertEqual(error, '')
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_invalid_option(self):
         (rc, output, error) = self.invokeAsSubprocess(extraParams=['--invalid-option'])
         self.assertEqual(2, rc)
         self.assertRegex(error, 'ERROR: unrecognized.*')
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_dont_print_body(self):
         (rc, output, error) = self.invokeAsSubprocess(extraParams=['--no-body'])
         self.assertEqual(1, rc)
         self.assertFalse(self.existsByTime())
         self.assertRegex(error, "body.*any.*attachments")
+        self.assertTrue(self.existsByTimeWarning())
+        self.assertRegex(self.getWarningFileContents(), "body.*any.*attachments")
 
     def test_no_message_headers(self):
         (rc, output, error) = self.invokeAsSubprocess()
         self.assertEqual(0, rc)
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_withinputfile(self):
         self.addHeaders()
@@ -47,6 +53,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertEqual(0, rc)
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_nosubject(self):
         self.addHeaders(Email2PDFTestCase.DEFAULT_FROM, Email2PDFTestCase.DEFAULT_TO, None)
@@ -54,6 +61,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertEqual(0, rc)
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent(self):
         self.addHeaders()
@@ -63,6 +71,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_upsidedown(self):
         self.addHeaders()
@@ -72,6 +81,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "ɯɐɹƃoɹd ɟpdᄅlᴉɐɯǝ ǝɥʇ ɟo ʇsǝʇ ɐ sᴉ sᴉɥʇ ollǝH")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_poundsign_iso88591(self):
         self.addHeaders()
@@ -82,6 +92,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(self.getPDFText(path), "Hello - this email costs \xa35!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_notrailingslash(self):
         self.setPlainContent("Hello!")
@@ -90,6 +101,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime("/tmp"))
         self.assertRegex(self.getPDFText(self.getTimedFilename("/tmp/")), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_trailingslash(self):
         self.setPlainContent("Hello!")
@@ -98,6 +110,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime("/tmp/"))
         self.assertRegex(self.getPDFText(self.getTimedFilename("/tmp/")), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_outputfileoverrides(self):
         filename = os.path.join(self.examineDir, "outputFileOverrides.pdf")
@@ -109,6 +122,7 @@ class TestBasic(Email2PDFTestCase):
             self.assertFalse(self.existsByTime(pathname))
             self.assertTrue(os.path.exists(filename))
             self.assertRegex(self.getPDFText(filename), "Hello!")
+            self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_fileexist(self):
         self.setPlainContent("Hello!")
@@ -116,6 +130,7 @@ class TestBasic(Email2PDFTestCase):
             (rc, output, error) = self.invokeAsSubprocess(outputFile=tmpfile.name, okToExist=True)
             self.assertEqual(2, rc)
             self.assertRegex(error, "file.*exist")
+            self.assertFalse(self.existsByTimeWarning())
 
     def test_verbose(self):
         self.setPlainContent("Hello!")
@@ -124,6 +139,7 @@ class TestBasic(Email2PDFTestCase):
         self.assertNotEqual('', error)
         self.assertTrue(self.existsByTime())
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_veryverbose(self):
         self.setPlainContent("Hello!")
@@ -132,3 +148,4 @@ class TestBasic(Email2PDFTestCase):
         self.assertNotEqual('', error)
         self.assertTrue(self.existsByTime())
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
diff --git a/tests/Subprocess/test_Subprocess_MIME.py b/tests/Subprocess/test_Subprocess_MIME.py
index eef09ed..b30fe95 100644
--- a/tests/Subprocess/test_Subprocess_MIME.py
+++ b/tests/Subprocess/test_Subprocess_MIME.py
@@ -17,6 +17,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual(0, rc)
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_simple(self):
         self.addHeaders()
@@ -24,6 +25,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual(0, rc)
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_nosubject(self):
         self.addHeaders(Email2PDFTestCase.DEFAULT_FROM, Email2PDFTestCase.DEFAULT_TO, None)
@@ -31,6 +33,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual(0, rc)
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_html(self):
         self.addHeaders()
@@ -40,6 +43,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some\sbasic\stextual\scontent")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_attachtext_upsidedown(self):
         self.addHeaders()
@@ -49,6 +53,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "ɯɐɹƃoɹd\sɟpdᄅlᴉɐɯǝ\sǝɥʇ\sɟo\sʇsǝʇ\sɐ\ssᴉ\ssᴉɥʇ\sollǝH")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_attachhtml_upsidedown(self):
         self.addHeaders()
@@ -58,6 +63,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertEqual('', error)
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "ɯɐɹƃoɹd\sɟpdᄅlᴉɐɯǝ\sǝɥʇ\sɟo\sʇsǝʇ\sɐ\ssᴉ\ssᴉɥʇ\sollǝH")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_html_entities_currency(self):
         path = os.path.join(self.examineDir, "htmlEntitiesCurrency.pdf")
@@ -68,6 +74,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(self.getPDFText(path), "Pounds:\s£7.14,\sAnother\sPounds:\s£7.14")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_html_poundsign_iso88591(self):
         self.addHeaders()
@@ -78,6 +85,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(self.getPDFText(path), "Hello\s-\sthis\semail\scosts\s\xa35!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_text_poundsign_iso88591(self):
         self.addHeaders()
@@ -88,6 +96,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(self.getPDFText(path), "Hello\s-\sthis\semail\scosts\s\xa35!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_poundsign_utf8_8bit(self):
         input_email = ("From: \"XYZ\" <xyz@abc.uk>\n"
@@ -108,6 +117,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(os.path.exists(path))
         self.assertRegex(self.getPDFText(path), "Price\sis\s£45.00")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plainandhtml(self):
         self.addHeaders()
@@ -118,6 +128,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertEqual('', error)
         self.assertTrue(self.existsByTime())
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some\sbasic\sHTML\scontent")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_pdf(self):
         self.addHeaders()
@@ -130,6 +141,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some\sbasic\stextual\scontent")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some\sPDF\scontent")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_plaincontent_outputfileoverrides_with_attachments(self):
         mainFilename = os.path.join(self.examineDir, "outputFileOverridesWithAttachments.pdf")
@@ -149,6 +161,7 @@ class TestMIME(Email2PDFTestCase):
             self.assertTrue(os.path.exists(os.path.join(tempdir, attachmentFilename)))
             self.assertRegex(self.getPDFText(mainFilename), "Hello!")
             self.assertRegex(self.getPDFText(os.path.join(tempdir, attachmentFilename)), "Some\sPDF\scontent")
+            self.assertFalse(self.existsByTimeWarning())
 
     def test_remote_image_does_exist(self):
         if self.isOnline:
@@ -159,6 +172,7 @@ class TestMIME(Email2PDFTestCase):
             self.assertEqual(0, rc)
             self.assertEqual('', error)
             self.assertTrue(os.path.exists(path))
+            self.assertFalse(self.existsByTimeWarning())
         else:
             self.skipTest("Not online.")
 
@@ -171,6 +185,7 @@ class TestMIME(Email2PDFTestCase):
             self.assertEqual(0, rc)
             self.assertEqual('', error)
             self.assertTrue(os.path.exists(path))
+            self.assertFalse(self.existsByTimeWarning())
         else:
             self.skipTest("Not online.")
 
@@ -184,6 +199,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, imageFilename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_non_embedded_image_jpeg_add_prefix_date(self):
         self.addHeaders()
@@ -195,6 +211,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, datetime.now().strftime("%Y-%m-%d-") + imageFilename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_non_embedded_image_png(self):
         self.addHeaders()
@@ -206,6 +223,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(self.existsByTime())
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, imageFilename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_non_embedded_image_and_pdf(self):
         self.addHeaders()
@@ -220,6 +238,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertTrue(os.path.exists(os.path.join(self.workingDir, imageFilename)))
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Hello!")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some\sPDF\scontent")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_2pdfs(self):
         self.addHeaders()
@@ -237,6 +256,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename)), "Some PDF content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename2)), "Some More PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_pdf_exists(self):
         self.addHeaders()
@@ -259,6 +279,7 @@ class TestMIME(Email2PDFTestCase):
         self.assertRegex(self.getPDFText(self.getTimedFilename()), "Some basic textual content")
         self.assertIsNone(self.getPDFText(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, uniqueName)), "Some PDF content")
+        self.assertFalse(self.existsByTimeWarning())
 
     def test_2pdfs_oneexists(self):
         self.addHeaders()
@@ -288,3 +309,4 @@ class TestMIME(Email2PDFTestCase):
         self.assertIsNone(self.getPDFText(os.path.join(self.workingDir, filename)))
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, uniqueName)), "Some PDF content")
         self.assertRegex(self.getPDFText(os.path.join(self.workingDir, filename2)), "Some More PDF content")
+        self.assertFalse(self.existsByTimeWarning())