Looks like something is wrong and pytest fails in units coparing time. I'm using t

Here is pytest output: <div class="highlight highlight-text-shell-sessi
Mostly because it’s <a href="https://github.com/kellyjonbrazil/jc/blob/master/CONTRIBU
Here is possible way how to solve that: <a href="https://stackoverflow.com/questio
1.25.3: pytest fails in nits which are comparing time,about kellyjonbrazil/jc

Comments (8)

kloczek commented on August 12, 2024
Here is pytest output:
=================================== FAILURES ===================================
______________________ MyTests.test_cbt_multiple_rows_raw ______________________

self = <tests.test_cbt.MyTests testMethod=test_cbt_multiple_rows_raw>

    def test_cbt_multiple_rows_raw(self):
        """
        Test 'cbt' with multiple rows raw
        """
>       self.assertEqual(jc.parsers.cbt.parse(self.multiple_rows, quiet=True, raw=True), self.multiple_rows_raw_json)
E       AssertionError: Lists differ: [{'ke[137 chars]: 946688400, 'timestamp_epoch_utc': None}]}, {[179 chars]e}]}] != [{'ke[137 chars]: 946717200, 'timestamp_epoch_utc': None}]}, {[179 chars]e}]}]
E
E       First differing element 0:
E       {'key[116 chars]', 'timestamp_epoch': 946688400, 'timestamp_epoch_utc': None}]}
E       {'key[116 chars]', 'timestamp_epoch': 946717200, 'timestamp_epoch_utc': None}]}
E
E       Diff is 798 characters long. Set self.maxDiff to None to see it.

tests/test_cbt.py:60: AssertionError
___________________________ MyTests.test_cef_sample ____________________________

self = <tests.test_cef.MyTests testMethod=test_cef_sample>

    def test_cef_sample(self):
        """
        Test with sample cef log
        """
>       self.assertEqual(jc.parsers.cef.parse(self.cef, quiet=True), self.cef_json)
E       AssertionError: Lists differ: [{'de[4035 chars]1604838600, 'start_epoch_utc': 1604838600, 'Ho[7030 chars]one}] != [{'de[4035 chars]1604867400, 'start_epoch_utc': 1604838600, 'Ho[7030 chars]one}]
E
E       First differing element 5:
E       {'dev[375 chars]1604838600, 'start_epoch_utc': 1604838600, 'Ho[331 chars]0000}
E       {'dev[375 chars]1604867400, 'start_epoch_utc': 1604838600, 'Ho[331 chars]0000}
E
E       Diff is 12895 characters long. Set self.maxDiff to None to see it.

tests/test_cef.py:30: AssertionError
__________________________ MyTests.test_cef_s_sample ___________________________

self = <tests.test_cef_s.MyTests testMethod=test_cef_s_sample>

    def test_cef_s_sample(self):
        """
        Test with sample cef log
        """
>       self.assertEqual(list(jc.parsers.cef_s.parse(self.cef.splitlines(), quiet=True)), self.cef_streaming_json)
E       AssertionError: Lists differ: [{'de[4035 chars]1604838600, 'start_epoch_utc': 1604838600, 'Ho[7030 chars]one}] != [{'de[4035 chars]1604867400, 'start_epoch_utc': 1604838600, 'Ho[7030 chars]one}]
E
E       First differing element 5:
E       {'dev[375 chars]1604838600, 'start_epoch_utc': 1604838600, 'Ho[331 chars]0000}
E       {'dev[375 chars]1604867400, 'start_epoch_utc': 1604838600, 'Ho[331 chars]0000}
E
E       Diff is 12895 characters long. Set self.maxDiff to None to see it.

tests/test_cef_s.py:32: AssertionError
______________________ MyTests.test_certbot_certificates _______________________

self = <tests.test_certbot.MyTests testMethod=test_certbot_certificates>

    def test_certbot_certificates(self):
        """
        Test 'certbot certificates'
        """
>       self.assertEqual(
            parse(self.f_in['certificates'], quiet=True),
            self.f_json['certificates']
        )
E       AssertionError: {'cer[403 chars]1683768790, 'expiration_date_epoch_utc': 16837[548 chars]0'}]} != {'cer[403 chars]1683793990, 'expiration_date_epoch_utc': 16837[548 chars]0'}]}
E       Diff is 1790 characters long. Set self.maxDiff to None to see it.

tests/test_certbot.py:43: AssertionError
_______________________________ MyTests.test_clf _______________________________

self = <tests.test_clf.MyTests testMethod=test_clf>

    def test_clf(self):
        """
        Test 'clf' with various log lines
        """
>       self.assertEqual(
            parse(self.f_in['clf'], quiet=True),
            self.f_json['clf']
        )
E       AssertionError: Lists differ: [{'ho[423 chars]: 971186136, 'epoch_utc': None}, {'host': '1.1[7289 chars]132}] != [{'ho[423 chars]: 971211336, 'epoch_utc': None}, {'host': '1.1[7289 chars]132}]
E
E       First differing element 0:
E       {'hos[390 chars]t_version': 'HTTPS/1.0', 'epoch': 971186136, 'epoch_utc': None}
E       {'hos[390 chars]t_version': 'HTTPS/1.0', 'epoch': 971211336, 'epoch_utc': None}
E
E       Diff is 10453 characters long. Set self.maxDiff to None to see it.

tests/test_clf.py:40: AssertionError
________________________ MyTests.test_clf_s_centos_7_7 _________________________

self = <tests.test_clf_s.MyTests testMethod=test_clf_s_centos_7_7>

    def test_clf_s_centos_7_7(self):
        """
        Test 'clf-s' with various logs
        """
>       self.assertEqual(
            list(parse(self.f_in['clf_s'].splitlines(), quiet=True)),
            self.f_json['clf_s']
        )
E       AssertionError: Lists differ: [{'ho[423 chars]: 971186136, 'epoch_utc': None}, {'host': '1.1[7289 chars]132}] != [{'ho[423 chars]: 971211336, 'epoch_utc': None}, {'host': '1.1[7289 chars]132}]
E
E       First differing element 0:
E       {'hos[390 chars]t_version': 'HTTPS/1.0', 'epoch': 971186136, 'epoch_utc': None}
E       {'hos[390 chars]t_version': 'HTTPS/1.0', 'epoch': 971211336, 'epoch_utc': None}
E
E       Diff is 10453 characters long. Set self.maxDiff to None to see it.

tests/test_clf_s.py:43: AssertionError
______________________________ MyTests.test_date _______________________________

self = <tests.test_date.MyTests testMethod=test_date>

    def test_date(self):
        """
        Test 'date'
        """
>       self.assertEqual(jc.parsers.date.parse(self.generic_date, quiet=True), self.generic_date_json)
E       AssertionError: {'yea[267 chars]epoch': 1596445971, 'epoch_utc': None, 'timezone_aware': False} != {'yea[267 chars]epoch': 1596471171, 'epoch_utc': None, 'timezone_aware': False}
E         {'day': 3,
E          'day_of_year': 216,
E       -  'epoch': 1596445971,
E       ?                ^^^
E
E       +  'epoch': 1596471171,
E       ?                ^^^
E
E          'epoch_utc': None,
E          'hour': 9,
E          'hour_24': 9,
E          'iso': '2020-08-03T09:12:51',
E          'minute': 12,
E          'month': 'Aug',
E          'month_num': 8,
E          'period': 'AM',
E          'second': 51,
E          'timezone': 'PDT',
E          'timezone_aware': False,
E          'utc_offset': None,
E          'week_of_year': 31,
E          'weekday': 'Mon',
E          'weekday_num': 1,
E          'year': 2020}

tests/test_date.py:54: AssertionError
_______________________ MyTests.test_date_after_midnight _______________________

self = <tests.test_date.MyTests testMethod=test_date_after_midnight>

    def test_date_after_midnight(self):
        """
        Test 'date' 24-hour conversion just after midnight
        """
>       self.assertEqual(jc.parsers.date.parse(self.generic_date_after_midnight, quiet=True), self.generic_date_after_midnight_json)
E       AssertionError: {'yea[282 chars]': 1616547287, 'epoch_utc': 1616547287, 'timezone_aware': True} != {'yea[282 chars]': 1616572487, 'epoch_utc': 1616547287, 'timezone_aware': True}
E         {'day': 24,
E          'day_of_year': 83,
E       -  'epoch': 1616547287,
E       ?                -
E
E       +  'epoch': 1616572487,
E       ?                  +
E
E          'epoch_utc': 1616547287,
E          'hour': 12,
E          'hour_24': 0,
E          'iso': '2021-03-24T00:54:47+00:00',
E          'minute': 54,
E          'month': 'Mar',
E          'month_num': 3,
E          'period': 'AM',
E          'second': 47,
E          'timezone': 'UTC',
E          'timezone_aware': True,
E          'utc_offset': '+0000',
E          'week_of_year': 12,
E          'weekday': 'Wed',
E          'weekday_num': 3,
E          'year': 2021}

tests/test_date.py:66: AssertionError
______________________ MyTests.test_date_am_ubuntu_20_04 _______________________

self = <tests.test_date.MyTests testMethod=test_date_am_ubuntu_20_04>

    def test_date_am_ubuntu_20_04(self):
        """
        Test 'date' on Ubuntu 20.4 with LANG=en_US.UTF-8 (uses 12-hour clock) with AM time
        """
>       self.assertEqual(jc.parsers.date.parse(self.ubuntu_20_04_date, quiet=True), self.ubuntu_20_04_date_json)
E       AssertionError: {'yea[276 chars]': 1609808524, 'epoch_utc': 1609808524, 'timezone_aware': True} != {'yea[276 chars]': 1609837324, 'epoch_utc': 1609808524, 'timezone_aware': True}
E         {'day': 5,
E          'day_of_year': 5,
E       -  'epoch': 1609808524,
E       ?                ^^^
E
E       +  'epoch': 1609837324,
E       ?                ^^^
E
E          'epoch_utc': 1609808524,
E          'hour': 1,
E          'hour_24': 1,
E          'iso': '2021-01-05T01:02:04+00:00',
E          'minute': 2,
E          'month': 'Jan',
E          'month_num': 1,
E          'period': 'AM',
E          'second': 4,
E          'timezone': 'UTC',
E          'timezone_aware': True,
E          'utc_offset': '+0000',
E          'week_of_year': 1,
E          'weekday': 'Tue',
E          'weekday_num': 2,
E          'year': 2021}

tests/test_date.py:72: AssertionError
______________________ MyTests.test_date_before_midnight _______________________

self = <tests.test_date.MyTests testMethod=test_date_before_midnight>

    def test_date_before_midnight(self):
        """
        Test 'date' 24-hour conversion just before midnight
        """
>       self.assertEqual(jc.parsers.date.parse(self.generic_date_before_midnight, quiet=True), self.generic_date_before_midnight_json)
E       AssertionError: {'yea[283 chars]': 1616630087, 'epoch_utc': 1616630087, 'timezone_aware': True} != {'yea[283 chars]': 1616655287, 'epoch_utc': 1616630087, 'timezone_aware': True}
E         {'day': 24,
E          'day_of_year': 83,
E       -  'epoch': 1616630087,
E       ?                ^^^
E
E       +  'epoch': 1616655287,
E       ?                ^^^
E
E          'epoch_utc': 1616630087,
E          'hour': 11,
E          'hour_24': 23,
E          'iso': '2021-03-24T23:54:47+00:00',
E          'minute': 54,
E          'month': 'Mar',
E          'month_num': 3,
E          'period': 'PM',
E          'second': 47,
E          'timezone': 'UTC',
E          'timezone_aware': True,
E          'utc_offset': '+0000',
E          'week_of_year': 12,
E          'weekday': 'Wed',
E          'weekday_num': 3,
E          'year': 2021}

tests/test_date.py:60: AssertionError
______________________ MyTests.test_date_pm_ubuntu_20_04 _______________________

self = <tests.test_date.MyTests testMethod=test_date_pm_ubuntu_20_04>

    def test_date_pm_ubuntu_20_04(self):
        """
        Test 'date' on Ubuntu 20.4 with LANG=en_US.UTF-8 (uses 12-hour clock) with PM time
        """
>       self.assertEqual(jc.parsers.date.parse(self.ubuntu_20_04_date2, quiet=True), self.ubuntu_20_04_date2_json)
E       AssertionError: {'yea[282 chars]': 1616532329, 'epoch_utc': 1616532329, 'timezone_aware': True} != {'yea[282 chars]': 1616557529, 'epoch_utc': 1616532329, 'timezone_aware': True}
E         {'day': 23,
E          'day_of_year': 82,
E       -  'epoch': 1616532329,
E       ?                ^^^
E
E       +  'epoch': 1616557529,
E       ?                ^^^
E
E          'epoch_utc': 1616532329,
E          'hour': 8,
E          'hour_24': 20,
E          'iso': '2021-03-23T20:45:29+00:00',
E          'minute': 45,
E          'month': 'Mar',
E          'month_num': 3,
E          'period': 'PM',
E          'second': 29,
E          'timezone': 'UTC',
E          'timezone_aware': True,
E          'utc_offset': '+0000',
E          'week_of_year': 12,
E          'weekday': 'Tue',
E          'weekday_num': 2,
E          'year': 2021}

tests/test_date.py:78: AssertionError
_______________________ MyTests.test_dig_aaaa_centos_7_7 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_aaaa_centos_7_7>

    def test_dig_aaaa_centos_7_7(self):
        """
        Test 'dig AAAA' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.dig.parse(self.centos_7_7_dig_aaaa, quiet=True), self.centos_7_7_dig_aaaa_json)
E       AssertionError: Lists differ: [{'id[516 chars] 'rcvd': 71, 'when_epoch': 1572412373, 'when_epoch_utc': None}] != [{'id[516 chars] 'rcvd': 71, 'when_epoch': 1572437573, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[514 chars], 'rcvd': 71, 'when_epoch': 1572412373, 'when_epoch_utc': None}
E       {'id'[514 chars], 'rcvd': 71, 'when_epoch': 1572437573, 'when_epoch_utc': None}
E
E       Diff is 800 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:192: AssertionError
______________________ MyTests.test_dig_aaaa_osx_10_11_6 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_aaaa_osx_10_11_6>

    def test_dig_aaaa_osx_10_11_6(self):
        """
        Test 'dig -aaaa' on OSX 10.11.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_11_6_dig_aaaa, quiet=True), self.osx_10_11_6_dig_aaaa_json)
E       AssertionError: Lists differ: [{'id[536 chars] 'rcvd': 71, 'when_epoch': 1576083457, 'when_epoch_utc': None}] != [{'id[536 chars] 'rcvd': 71, 'when_epoch': 1576112257, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[534 chars], 'rcvd': 71, 'when_epoch': 1576083457, 'when_epoch_utc': None}
E       {'id'[534 chars], 'rcvd': 71, 'when_epoch': 1576112257, 'when_epoch_utc': None}
E
E       Diff is 821 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:228: AssertionError
______________________ MyTests.test_dig_aaaa_osx_10_14_6 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_aaaa_osx_10_14_6>

    def test_dig_aaaa_osx_10_14_6(self):
        """
        Test 'dig -aaaa' on OSX 10.14.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_14_6_dig_aaaa, quiet=True), self.osx_10_14_6_dig_aaaa_json)
E       AssertionError: Lists differ: [{'id[535 chars] 'rcvd': 71, 'when_epoch': 1576083290, 'when_epoch_utc': None}] != [{'id[535 chars] 'rcvd': 71, 'when_epoch': 1576112090, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[533 chars], 'rcvd': 71, 'when_epoch': 1576083290, 'when_epoch_utc': None}
E       {'id'[533 chars], 'rcvd': 71, 'when_epoch': 1576112090, 'when_epoch_utc': None}
E
E       Diff is 819 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:246: AssertionError
______________________ MyTests.test_dig_aaaa_ubuntu_18_4 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_aaaa_ubuntu_18_4>

    def test_dig_aaaa_ubuntu_18_4(self):
        """
        Test 'dig AAAA' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.dig.parse(self.ubuntu_18_4_dig_aaaa, quiet=True), self.ubuntu_18_4_dig_aaaa_json)
E       AssertionError: Lists differ: [{'id[519 chars]': 71, 'when_epoch': 1572531664, 'when_epoch_utc': 1572531664}] != [{'id[519 chars]': 71, 'when_epoch': 1572556864, 'when_epoch_utc': 1572531664}]
E
E       First differing element 0:
E       {'id'[517 chars]d': 71, 'when_epoch': 1572531664, 'when_epoch_utc': 1572531664}
E       {'id'[517 chars]d': 71, 'when_epoch': 1572556864, 'when_epoch_utc': 1572531664}
E
E       Diff is 803 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:198: AssertionError
_________________________ MyTests.test_dig_additional __________________________

self = <tests.test_dig.MyTests testMethod=test_dig_additional>

    def test_dig_additional(self):
        """
        Test 'dig' with additional section
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_additional, quiet=True), self.generic_dig_additional_json)
E       AssertionError: Lists differ: [{'id[1614 chars]'rcvd': 287, 'when_epoch': 1536002600, 'when_epoch_utc': None}] != [{'id[1614 chars]'rcvd': 287, 'when_epoch': 1536027800, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[1612 chars] 'rcvd': 287, 'when_epoch': 1536002600, 'when_epoch_utc': None}
E       {'id'[1612 chars] 'rcvd': 287, 'when_epoch': 1536027800, 'when_epoch_utc': None}
E
E       Diff is 2970 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:270: AssertionError
_________________________ MyTests.test_dig_additional2 _________________________

self = <tests.test_dig.MyTests testMethod=test_dig_additional2>

    def test_dig_additional2(self):
        """
        Test 'dig' with additional section
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_additional2, quiet=True), self.generic_dig_additional2_json)
E       AssertionError: Lists differ: [{'id[1898 chars]'rcvd': 432, 'when_epoch': 1536002724, 'when_epoch_utc': None}] != [{'id[1898 chars]'rcvd': 432, 'when_epoch': 1536027924, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[1896 chars] 'rcvd': 432, 'when_epoch': 1536002724, 'when_epoch_utc': None}
E       {'id'[1896 chars] 'rcvd': 432, 'when_epoch': 1536027924, 'when_epoch_utc': None}
E
E       Diff is 3420 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:276: AssertionError
_________________________ MyTests.test_dig_additional3 _________________________

self = <tests.test_dig.MyTests testMethod=test_dig_additional3>

    def test_dig_additional3(self):
        """
        Test 'dig' with additional section
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_additional3, quiet=True), self.generic_dig_additional3_json)
E       AssertionError: Lists differ: [{'id[2430 chars]'rcvd': 432, 'when_epoch': 1536002724, 'when_epoch_utc': None}] != [{'id[2430 chars]'rcvd': 432, 'when_epoch': 1536027924, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[2428 chars] 'rcvd': 432, 'when_epoch': 1536002724, 'when_epoch_utc': None}
E       {'id'[2428 chars] 'rcvd': 432, 'when_epoch': 1536027924, 'when_epoch_utc': None}
E
E       Diff is 4336 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:282: AssertionError
________________________ MyTests.test_dig_answer_spaces ________________________

self = <tests.test_dig.MyTests testMethod=test_dig_answer_spaces>

    def test_dig_answer_spaces(self):
        """
        Test 'dig' with spaces in the answer data (e.g. TXT responses)
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_answer_spaces, quiet=True), self.generic_dig_answer_spaces_json)
E       AssertionError: Lists differ: [{'id[737 chars]'rcvd': 104, 'when_epoch': 1612506538, 'when_epoch_utc': None}] != [{'id[737 chars]'rcvd': 104, 'when_epoch': 1612535338, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[735 chars] 'rcvd': 104, 'when_epoch': 1612506538, 'when_epoch_utc': None}
E       {'id'[735 chars] 'rcvd': 104, 'when_epoch': 1612535338, 'when_epoch_utc': None}
E
E       Diff is 1131 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:264: AssertionError
_______________________ MyTests.test_dig_axfr_centos_7_7 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_axfr_centos_7_7>

    def test_dig_axfr_centos_7_7(self):
        """
        Test 'dig axfr' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.dig.parse(self.centos_7_7_dig_axfr, quiet=True), self.centos_7_7_dig_axfr_json)
E       AssertionError: Lists differ: [{'ax[6154 chars]ytes 1994)', 'when_epoch': 1585166507, 'when_epoch_utc': None}] != [{'ax[6154 chars]ytes 1994)', 'when_epoch': 1585191707, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'axf[6152 chars]bytes 1994)', 'when_epoch': 1585166507, 'when_epoch_utc': None}
E       {'axf[6152 chars]bytes 1994)', 'when_epoch': 1585191707, 'when_epoch_utc': None}
E
E       Diff is 9972 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:204: AssertionError
______________________ MyTests.test_dig_axfr_osx_10_14_6 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_axfr_osx_10_14_6>

    def test_dig_axfr_osx_10_14_6(self):
        """
        Test 'dig axfr' on OSX 10.14.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_14_6_dig_axfr, quiet=True), self.osx_10_14_6_dig_axfr_json)
E       AssertionError: Lists differ: [{'ax[6154 chars]ytes 1994)', 'when_epoch': 1585240266, 'when_epoch_utc': None}] != [{'ax[6154 chars]ytes 1994)', 'when_epoch': 1585265466, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'axf[6152 chars]bytes 1994)', 'when_epoch': 1585240266, 'when_epoch_utc': None}
E       {'axf[6152 chars]bytes 1994)', 'when_epoch': 1585265466, 'when_epoch_utc': None}
E
E       Diff is 9971 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:252: AssertionError
______________________ MyTests.test_dig_axfr_ubuntu_18_4 _______________________

self = <tests.test_dig.MyTests testMethod=test_dig_axfr_ubuntu_18_4>

    def test_dig_axfr_ubuntu_18_4(self):
        """
        Test 'dig axfr' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.dig.parse(self.ubuntu_18_4_dig_axfr, quiet=True), self.ubuntu_18_4_dig_axfr_json)
E       AssertionError: Lists differ: [{'ax[6154 chars]ytes 1994)', 'when_epoch': 1585146895, 'when_epoch_utc': None}] != [{'ax[6154 chars]ytes 1994)', 'when_epoch': 1585172095, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'axf[6152 chars]bytes 1994)', 'when_epoch': 1585146895, 'when_epoch_utc': None}
E       {'axf[6152 chars]bytes 1994)', 'when_epoch': 1585172095, 'when_epoch_utc': None}
E
E       Diff is 9972 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:210: AssertionError
_________________________ MyTests.test_dig_centos_7_7 __________________________

self = <tests.test_dig.MyTests testMethod=test_dig_centos_7_7>

    def test_dig_centos_7_7(self):
        """
        Test 'dig' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.dig.parse(self.centos_7_7_dig, quiet=True), self.centos_7_7_dig_json)
E       AssertionError: Lists differ: [{'id[641 chars]1572412402, 'when_epoch_utc': None}, {'id': 34[553 chars]one}] != [{'id[641 chars]1572437602, 'when_epoch_utc': None}, {'id': 34[553 chars]one}]
E
E       First differing element 0:
E       {'id'[612 chars], 'rcvd': 95, 'when_epoch': 1572412402, 'when_epoch_utc': None}
E       {'id'[612 chars], 'rcvd': 95, 'when_epoch': 1572437602, 'when_epoch_utc': None}
E
E       Diff is 1763 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:168: AssertionError
____________________________ MyTests.test_dig_edns _____________________________

self = <tests.test_dig.MyTests testMethod=test_dig_edns>

    def test_dig_edns(self):
        """
        Test 'dig' with edns info
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_edns, quiet=True), self.generic_dig_edns_json)
E       AssertionError: Lists differ: [{'id[554 chars] 'rcvd': 59, 'when_epoch': 1618481990, 'when_epoch_utc': None}] != [{'id[554 chars] 'rcvd': 59, 'when_epoch': 1618507190, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[552 chars], 'rcvd': 59, 'when_epoch': 1618481990, 'when_epoch_utc': None}
E       {'id'[552 chars], 'rcvd': 59, 'when_epoch': 1618507190, 'when_epoch_utc': None}
E
E       Diff is 864 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:288: AssertionError
____________________________ MyTests.test_dig_edns2 ____________________________

self = <tests.test_dig.MyTests testMethod=test_dig_edns2>

    def test_dig_edns2(self):
        """
        Test 'dig' with edns info
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_edns2, quiet=True), self.generic_dig_edns2_json)
E       AssertionError: Lists differ: [{'id[518 chars] 1618582798, 'when_epoch_utc': None}, {'id': 3[540 chars]one}] != [{'id[518 chars] 1618607998, 'when_epoch_utc': None}, {'id': 3[540 chars]one}]
E
E       First differing element 0:
E       {'id'[490 chars], 'rcvd': 58, 'when_epoch': 1618582798, 'when_epoch_utc': None}
E       {'id'[490 chars], 'rcvd': 58, 'when_epoch': 1618607998, 'when_epoch_utc': None}
E
E       Diff is 1546 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:294: AssertionError
____________________________ MyTests.test_dig_edns3 ____________________________

self = <tests.test_dig.MyTests testMethod=test_dig_edns3>

    def test_dig_edns3(self):
        """
        Test 'dig' with edns info
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_edns3, quiet=True), self.generic_dig_edns3_json)
E       AssertionError: Lists differ: [{'id[1258 chars]'rcvd': 247, 'when_epoch': 1544191783, 'when_epoch_utc': None}] != [{'id[1258 chars]'rcvd': 247, 'when_epoch': 1544220583, 'when_epoch_utc': None}]
E
E       First differing element 1:
E       {'id'[911 chars] 'rcvd': 247, 'when_epoch': 1544191783, 'when_epoch_utc': None}
E       {'id'[911 chars] 'rcvd': 247, 'when_epoch': 1544220583, 'when_epoch_utc': None}
E
E       Diff is 1905 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:300: AssertionError
____________________________ MyTests.test_dig_nsid _____________________________

self = <tests.test_dig.MyTests testMethod=test_dig_nsid>

    def test_dig_nsid(self):
        """
        Test 'dig' with nsid info
        """
>       self.assertEqual(jc.parsers.dig.parse(self.generic_dig_nsid, quiet=True), self.generic_dig_nsid_json)
E       AssertionError: Lists differ: [{'id[542 chars] 'rcvd': 73, 'when_epoch': 1685795863, 'when_epoch_utc': None}] != [{'id[542 chars] 'rcvd': 73, 'when_epoch': 1685821063, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[540 chars], 'rcvd': 73, 'when_epoch': 1685795863, 'when_epoch_utc': None}
E       {'id'[540 chars], 'rcvd': 73, 'when_epoch': 1685821063, 'when_epoch_utc': None}
E
E       Diff is 852 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:306: AssertionError
_________________________ MyTests.test_dig_osx_10_11_6 _________________________

self = <tests.test_dig.MyTests testMethod=test_dig_osx_10_11_6>

    def test_dig_osx_10_11_6(self):
        """
        Test 'dig' on OSX 10.11.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_11_6_dig, quiet=True), self.osx_10_11_6_dig_json)
E       AssertionError: Lists differ: [{'id[974 chars] 1576083457, 'when_epoch_utc': None}, {'id': 5[573 chars]one}] != [{'id[974 chars] 1576112257, 'when_epoch_utc': None}, {'id': 5[573 chars]one}]
E
E       First differing element 0:
E       {'id'[946 chars] 'rcvd': 143, 'when_epoch': 1576083457, 'when_epoch_utc': None}
E       {'id'[946 chars] 'rcvd': 143, 'when_epoch': 1576112257, 'when_epoch_utc': None}
E
E       Diff is 2353 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:216: AssertionError
_________________________ MyTests.test_dig_osx_10_14_6 _________________________

self = <tests.test_dig.MyTests testMethod=test_dig_osx_10_14_6>

    def test_dig_osx_10_14_6(self):
        """
        Test 'dig' on OSX 10.14.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_14_6_dig, quiet=True), self.osx_10_14_6_dig_json)
E       AssertionError: Lists differ: [{'id[969 chars] 1576083290, 'when_epoch_utc': None}, {'id': 6[572 chars]one}] != [{'id[969 chars] 1576112090, 'when_epoch_utc': None}, {'id': 6[572 chars]one}]
E
E       First differing element 0:
E       {'id'[941 chars] 'rcvd': 143, 'when_epoch': 1576083290, 'when_epoch_utc': None}
E       {'id'[941 chars] 'rcvd': 143, 'when_epoch': 1576112090, 'when_epoch_utc': None}
E
E       Diff is 2345 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:234: AssertionError
_________________________ MyTests.test_dig_ubuntu_18_4 _________________________

self = <tests.test_dig.MyTests testMethod=test_dig_ubuntu_18_4>

    def test_dig_ubuntu_18_4(self):
        """
        Test 'dig' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.dig.parse(self.ubuntu_18_4_dig, quiet=True), self.ubuntu_18_4_dig_json)
E       AssertionError: Lists differ: [{'id[948 chars]1572531664, 'when_epoch_utc': 1572531664}, {'i[561 chars]664}] != [{'id[948 chars]1572556864, 'when_epoch_utc': 1572531664}, {'i[561 chars]664}]
E
E       First differing element 0:
E       {'id'[925 chars]': 143, 'when_epoch': 1572531664, 'when_epoch_utc': 1572531664}
E       {'id'[925 chars]': 143, 'when_epoch': 1572556864, 'when_epoch_utc': 1572531664}
E
E       Diff is 2313 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:174: AssertionError
________________________ MyTests.test_dig_x_centos_7_7 _________________________

self = <tests.test_dig.MyTests testMethod=test_dig_x_centos_7_7>

    def test_dig_x_centos_7_7(self):
        """
        Test 'dig -x' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.dig.parse(self.centos_7_7_dig_x, quiet=True), self.centos_7_7_dig_x_json)
E       AssertionError: Lists differ: [{'id[518 chars] 'rcvd': 78, 'when_epoch': 1572412416, 'when_epoch_utc': None}] != [{'id[518 chars] 'rcvd': 78, 'when_epoch': 1572437616, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[516 chars], 'rcvd': 78, 'when_epoch': 1572412416, 'when_epoch_utc': None}
E       {'id'[516 chars], 'rcvd': 78, 'when_epoch': 1572437616, 'when_epoch_utc': None}
E
E       Diff is 803 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:180: AssertionError
________________________ MyTests.test_dig_x_osx_10_11_6 ________________________

self = <tests.test_dig.MyTests testMethod=test_dig_x_osx_10_11_6>

    def test_dig_x_osx_10_11_6(self):
        """
        Test 'dig -x' on OSX 10.11.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_11_6_dig_x, quiet=True), self.osx_10_11_6_dig_x_json)
E       AssertionError: Lists differ: [{'id[539 chars] 'rcvd': 78, 'when_epoch': 1576083457, 'when_epoch_utc': None}] != [{'id[539 chars] 'rcvd': 78, 'when_epoch': 1576112257, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[537 chars], 'rcvd': 78, 'when_epoch': 1576083457, 'when_epoch_utc': None}
E       {'id'[537 chars], 'rcvd': 78, 'when_epoch': 1576112257, 'when_epoch_utc': None}
E
E       Diff is 824 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:222: AssertionError
________________________ MyTests.test_dig_x_osx_10_14_6 ________________________

self = <tests.test_dig.MyTests testMethod=test_dig_x_osx_10_14_6>

    def test_dig_x_osx_10_14_6(self):
        """
        Test 'dig -x' on OSX 10.14.6
        """
>       self.assertEqual(jc.parsers.dig.parse(self.osx_10_14_6_dig_x, quiet=True), self.osx_10_14_6_dig_x_json)
E       AssertionError: Lists differ: [{'id[539 chars] 'rcvd': 78, 'when_epoch': 1576083291, 'when_epoch_utc': None}] != [{'id[539 chars] 'rcvd': 78, 'when_epoch': 1576112091, 'when_epoch_utc': None}]
E
E       First differing element 0:
E       {'id'[537 chars], 'rcvd': 78, 'when_epoch': 1576083291, 'when_epoch_utc': None}
E       {'id'[537 chars], 'rcvd': 78, 'when_epoch': 1576112091, 'when_epoch_utc': None}
E
E       Diff is 823 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:240: AssertionError
________________________ MyTests.test_dig_x_ubuntu_18_4 ________________________

self = <tests.test_dig.MyTests testMethod=test_dig_x_ubuntu_18_4>

    def test_dig_x_ubuntu_18_4(self):
        """
        Test 'dig -x' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.dig.parse(self.ubuntu_18_4_dig_x, quiet=True), self.ubuntu_18_4_dig_x_json)
E       AssertionError: Lists differ: [{'id[521 chars]': 78, 'when_epoch': 1572531665, 'when_epoch_utc': 1572531665}] != [{'id[521 chars]': 78, 'when_epoch': 1572556865, 'when_epoch_utc': 1572531665}]
E
E       First differing element 0:
E       {'id'[519 chars]d': 78, 'when_epoch': 1572531665, 'when_epoch_utc': 1572531665}
E       {'id'[519 chars]d': 78, 'when_epoch': 1572556865, 'when_epoch_utc': 1572531665}
E
E       Diff is 805 characters long. Set self.maxDiff to None to see it.

tests/test_dig.py:186: AssertionError
_________________________ MyTests.test_dir_windows_10 __________________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10>

    def test_dir_windows_10(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir, quiet=True),
                         self.windows_10_dir_json)
E       AssertionError: Lists differ: [{'da[141 chars] 1616598900}, {'date': '03/24/2021', 'time': '[2161 chars]540}] != [{'da[141 chars] 1616624100}, {'date': '03/24/2021', 'time': '[2161 chars]340}]
E
E       First differing element 0:
E       {'dat[89 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1616598900}
E       {'dat[89 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1616624100}
E
E       Diff is 3727 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:71: AssertionError
________________________ MyTests.test_dir_windows_10_C _________________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10_C>

    def test_dir_windows_10_C(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir_C, quiet=True),
                         self.windows_10_dir_json)
E       AssertionError: Lists differ: [{'da[141 chars] 1616598900}, {'date': '03/24/2021', 'time': '[2161 chars]540}] != [{'da[141 chars] 1616624100}, {'date': '03/24/2021', 'time': '[2161 chars]340}]
E
E       First differing element 0:
E       {'dat[89 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1616598900}
E       {'dat[89 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1616624100}
E
E       Diff is 3727 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:79: AssertionError
_______________________ MyTests.test_dir_windows_10_ODTC _______________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10_ODTC>

    def test_dir_windows_10_ODTC(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir_ODTC, quiet=True),
                         self.windows_10_dir_ODTC_json)
E       AssertionError: Lists differ: [{'da[152 chars] 1575684540}, {'date': '12/07/2019', 'time': '[2150 chars]900}] != [{'da[152 chars] 1575713340}, {'date': '12/07/2019', 'time': '[2150 chars]100}]
E
E       First differing element 0:
E       {'dat[100 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1575684540}
E       {'dat[100 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1575713340}
E
E       Diff is 3726 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:75: AssertionError
________________________ MyTests.test_dir_windows_10_S _________________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10_S>

    def test_dir_windows_10_S(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir_S, quiet=True),
                         self.windows_10_dir_S_json)
E       AssertionError: Lists differ: [{'da[141 chars] 1616598900}, {'date': '03/24/2021', 'time': '[4060 chars]720}] != [{'da[141 chars] 1616624100}, {'date': '03/24/2021', 'time': '[4060 chars]520}]
E
E       First differing element 0:
E       {'dat[89 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1616598900}
E       {'dat[89 chars]': 'C:\\Program Files\\Internet Explorer', 'epoch': 1616624100}
E
E       Diff is 6696 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:95: AssertionError
_______________________ MyTests.test_dir_windows_10_dirs _______________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10_dirs>

    def test_dir_windows_10_dirs(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir_dirs, quiet=True),
                         self.windows_10_dir_dirs_json)
E       AssertionError: Lists differ: [{'da[139 chars] 1616682960}, {'date': '03/25/2021', 'time': '[1087 chars]960}] != [{'da[139 chars] 1616708160}, {'date': '03/25/2021', 'time': '[1087 chars]160}]
E
E       First differing element 0:
E       {'dat[87 chars]nt': 'C:\\Users\\Yoda\\Desktop\\jc\\docs', 'epoch': 1616682960}
E       {'dat[87 chars]nt': 'C:\\Users\\Yoda\\Desktop\\jc\\docs', 'epoch': 1616708160}
E
E       Diff is 2066 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:91: AssertionError
______________________ MyTests.test_dir_windows_10_files _______________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10_files>

    def test_dir_windows_10_files(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir_files, quiet=True),
                         self.windows_10_dir_files_json)
E       AssertionError: Lists differ: [{'da[142 chars] 1616683080}, {'date': '03/25/2021', 'time': '[284 chars]960}] != [{'da[142 chars] 1616708280}, {'date': '03/25/2021', 'time': '[284 chars]160}]
E
E       First differing element 0:
E       {'dat[90 chars] 'parent': 'C:\\Users\\Yoda\\Desktop\\jc', 'epoch': 1616683080}
E       {'dat[90 chars] 'parent': 'C:\\Users\\Yoda\\Desktop\\jc', 'epoch': 1616708280}
E
E       Diff is 776 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:87: AssertionError
_______________________ MyTests.test_dir_windows_10_mix ________________________

self = <tests.test_dir.MyTests testMethod=test_dir_windows_10_mix>

    def test_dir_windows_10_mix(self):
>       self.assertEqual(jc.parsers.dir.parse(self.windows_10_dir_mix, quiet=True),
                         self.windows_10_dir_mix_json)
E       AssertionError: Lists differ: [{'da[142 chars] 1616683080}, {'date': '03/25/2021', 'time': '[934 chars]080}] != [{'da[142 chars] 1616708280}, {'date': '03/25/2021', 'time': '[934 chars]280}]
E
E       First differing element 0:
E       {'dat[90 chars] 'parent': 'C:\\Users\\Yoda\\Desktop\\jc', 'epoch': 1616683080}
E       {'dat[90 chars] 'parent': 'C:\\Users\\Yoda\\Desktop\\jc', 'epoch': 1616708280}
E
E       Diff is 1818 characters long. Set self.maxDiff to None to see it.

tests/test_dir.py:83: AssertionError
_____________________________ MyTests.test_git_log _____________________________

self = <tests.test_git_log.MyTests testMethod=test_git_log>

    def test_git_log(self):
        """
        Test 'git_log'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log, quiet=True), self.git_log_json)
E       AssertionError: Lists differ: [{'co[204 chars]1650449016, 'epoch_utc': None}, {'commit': '72[614254 chars]one}] != [{'co[204 chars]1650474216, 'epoch_utc': None}, {'commit': '72[614254 chars]one}]
E
E       First differing element 0:
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 857509 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:138: AssertionError
____________________ MyTests.test_git_log_blank_author_fix _____________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_blank_author_fix>

    def test_git_log_blank_author_fix(self):
        """
        Test 'git_log' fix for when a commit author has a blank name,
        empty email, or both
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_blank_author_fix, quiet=True), self.git_log_blank_author_fix_json)
E       AssertionError: Lists differ: [{'co[205 chars]1650449016, 'epoch_utc': None}, {'commit': '72[456 chars]one}] != [{'co[205 chars]1650474216, 'epoch_utc': None}, {'commit': '72[456 chars]one}]
E
E       First differing element 0:
E       {'com[171 chars]hor with a blank name', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[171 chars]hor with a blank name', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1010 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:249: AssertionError
_________________________ MyTests.test_git_log_fuller __________________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_fuller>

    def test_git_log_fuller(self):
        """
        Test 'git_log --format=fuller'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_fuller, quiet=True), self.git_log_fuller_json)
E       AssertionError: Lists differ: [{'co[332 chars]1650449016, 'epoch_utc': None}, {'commit': '72[922871 chars]one}] != [{'co[332 chars]1650474216, 'epoch_utc': None}, {'commit': '72[922871 chars]one}]
E
E       First differing element 0:
E       {'com[298 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[298 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1195450 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:198: AssertionError
_______________ MyTests.test_git_log_fuller_hash_in_message_fix ________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_fuller_hash_in_message_fix>

    def test_git_log_fuller_hash_in_message_fix(self):
        """
        Test 'git_log --format=fuller --stat' fix for when a commit message
        contains a line that is only a commit hash value.
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_fuller_hash_in_message_fix, quiet=True), self.git_log_fuller_hash_in_message_fix_json)
E       AssertionError: Lists differ: [{'co[758 chars]1572266542, 'epoch_utc': None}, {'commit': '91[976 chars]one}] != [{'co[758 chars]1572291742, 'epoch_utc': None}, {'commit': '91[976 chars]one}]
E
E       First differing element 0:
E       {'com[724 chars]7ce1dd26b811bd39a9467', 'epoch': 1572266542, 'epoch_utc': None}
E       {'com[724 chars]7ce1dd26b811bd39a9467', 'epoch': 1572291742, 'epoch_utc': None}
E
E       Diff is 2452 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:235: AssertionError
___________________ MyTests.test_git_log_fuller_is_hash_fix ____________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_fuller_is_hash_fix>

    def test_git_log_fuller_is_hash_fix(self):
        """
        Test 'git_log --format=fuller --stat' fix for when a commit message
        contains a line that evaluated as true to an older _is_hash regex
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_fuller_is_hash_regex_fix, quiet=True), self.git_log_fuller_is_hash_regex_fix_json)
E       AssertionError: Lists differ: [{'co[753 chars] 1593789589, 'epoch_utc': None}, {'commit': '2[10531 chars]one}] != [{'co[753 chars] 1593814789, 'epoch_utc': None}, {'commit': '2[10531 chars]one}]
E
E       First differing element 0:
E       {'com[720 chars]ckage, not pkg, repo.", 'epoch': 1593789589, 'epoch_utc': None}
E       {'com[720 chars]ckage, not pkg, repo.", 'epoch': 1593814789, 'epoch_utc': None}
E
E       Diff is 19288 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:242: AssertionError
____________________ MyTests.test_git_log_fuller_shortstat _____________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_fuller_shortstat>

    def test_git_log_fuller_shortstat(self):
        """
        Test 'git_log --format=fuller --shortstat'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_fuller_shortstat, quiet=True), self.git_log_fuller_shortstat_json)
E       AssertionError: Lists differ: [{'co[399 chars]1650449016, 'epoch_utc': None}, {'commit': '72[1073373 chars]one}] != [{'co[399 chars]1650474216, 'epoch_utc': None}, {'commit': '72[1073373 chars]one}]
E
E       First differing element 0:
E       {'com[365 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[365 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1355183 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:210: AssertionError
_______________________ MyTests.test_git_log_fuller_stat _______________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_fuller_stat>

    def test_git_log_fuller_stat(self):
        """
        Test 'git_log --format=fuller --stat'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_fuller_stat, quiet=True), self.git_log_fuller_stat_json)
E       AssertionError: Lists differ: [{'co[592 chars]1650449016, 'epoch_utc': None}, {'commit': '72[1898357 chars]one}] != [{'co[592 chars]1650474216, 'epoch_utc': None}, {'commit': '72[1898357 chars]one}]
E
E       First differing element 0:
E       {'com[558 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[558 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 2806146 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:204: AssertionError
_________________________ MyTests.test_git_log_medium __________________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_medium>

    def test_git_log_medium(self):
        """
        Test 'git_log --format=medium'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_medium, quiet=True), self.git_log_medium_json)
E       AssertionError: Lists differ: [{'co[204 chars]1650449016, 'epoch_utc': None}, {'commit': '72[614254 chars]one}] != [{'co[204 chars]1650474216, 'epoch_utc': None}, {'commit': '72[614254 chars]one}]
E
E       First differing element 0:
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 857509 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:162: AssertionError
____________________ MyTests.test_git_log_medium_shortstat _____________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_medium_shortstat>

    def test_git_log_medium_shortstat(self):
        """
        Test 'git_log --format=medium --shortstat'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_medium_shortstat, quiet=True), self.git_log_medium_shortstat_json)
E       AssertionError: Lists differ: [{'co[271 chars]1650449016, 'epoch_utc': None}, {'commit': '72[764756 chars]one}] != [{'co[271 chars]1650474216, 'epoch_utc': None}, {'commit': '72[764756 chars]one}]
E
E       First differing element 0:
E       {'com[237 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[237 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1017242 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:174: AssertionError
_______________________ MyTests.test_git_log_medium_stat _______________________

self = <tests.test_git_log.MyTests testMethod=test_git_log_medium_stat>

    def test_git_log_medium_stat(self):
        """
        Test 'git_log --format=medium --stat'
        """
>       self.assertEqual(jc.parsers.git_log.parse(self.git_log_medium_stat, quiet=True), self.git_log_medium_stat_json)
E       AssertionError: Lists differ: [{'co[464 chars]1650449016, 'epoch_utc': None}, {'commit': '72[1589740 chars]one}] != [{'co[464 chars]1650474216, 'epoch_utc': None}, {'commit': '72[1589740 chars]one}]
E
E       First differing element 0:
E       {'com[430 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[430 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 2468205 characters long. Set self.maxDiff to None to see it.

tests/test_git_log.py:168: AssertionError
____________________ MyTests.test_git_log_blank_author_fix _____________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_blank_author_fix>

    def test_git_log_blank_author_fix(self):
        """
        Test 'git_log' fix for when a commit author has a blank name,
        empty email, or both
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_blank_author_fix.splitlines(), quiet=True)), self.generic_git_log_blank_author_fix_streaming_json)
E       AssertionError: Lists differ: [{'co[205 chars]1650449016, 'epoch_utc': None}, {'commit': '72[456 chars]one}] != [{'co[205 chars]1650474216, 'epoch_utc': None}, {'commit': '72[456 chars]one}]
E
E       First differing element 0:
E       {'com[171 chars]hor with a blank name', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[171 chars]hor with a blank name', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1010 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:276: AssertionError
_______________ MyTests.test_git_log_fuller_hash_in_message_fix ________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_fuller_hash_in_message_fix>

    def test_git_log_fuller_hash_in_message_fix(self):
        """
        Test 'git_log --format=fuller --stat' fix for when a commit message
        contains a line that is only a commit hash value.
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_fuller_hash_in_message_fix.splitlines(), quiet=True)), self.generic_git_log_fuller_hash_in_message_fix_streaming_json)
E       AssertionError: Lists differ: [{'co[758 chars]1572266542, 'epoch_utc': None}, {'commit': '91[976 chars]one}] != [{'co[758 chars]1572291742, 'epoch_utc': None}, {'commit': '91[976 chars]one}]
E
E       First differing element 0:
E       {'com[724 chars]7ce1dd26b811bd39a9467', 'epoch': 1572266542, 'epoch_utc': None}
E       {'com[724 chars]7ce1dd26b811bd39a9467', 'epoch': 1572291742, 'epoch_utc': None}
E
E       Diff is 2452 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:262: AssertionError
___________________ MyTests.test_git_log_fuller_is_hash_fix ____________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_fuller_is_hash_fix>

    def test_git_log_fuller_is_hash_fix(self):
        """
        Test 'git_log --format=fuller --stat' fix for when a commit message
        contains a line that evaluated as true to an older _is_hash regex
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_fuller_is_hash_regex_fix.splitlines(), quiet=True)), self.generic_git_log_fuller_is_hash_regex_fix_streaming_json)
E       AssertionError: Lists differ: [{'co[753 chars] 1593789589, 'epoch_utc': None}, {'commit': '2[10531 chars]one}] != [{'co[753 chars] 1593814789, 'epoch_utc': None}, {'commit': '2[10531 chars]one}]
E
E       First differing element 0:
E       {'com[720 chars]ckage, not pkg, repo.", 'epoch': 1593789589, 'epoch_utc': None}
E       {'com[720 chars]ckage, not pkg, repo.", 'epoch': 1593814789, 'epoch_utc': None}
E
E       Diff is 19288 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:269: AssertionError
________________________ MyTests.test_git_log_fuller_s _________________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_fuller_s>

    def test_git_log_fuller_s(self):
        """
        Test 'git_log --format=fuller'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_fuller.splitlines(), quiet=True)), self.generic_git_log_fuller_streaming_json)
E       AssertionError: Lists differ: [{'co[332 chars]1650449016, 'epoch_utc': None}, {'commit': '72[922871 chars]one}] != [{'co[332 chars]1650474216, 'epoch_utc': None}, {'commit': '72[922871 chars]one}]
E
E       First differing element 0:
E       {'com[298 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[298 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1195450 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:225: AssertionError
___________________ MyTests.test_git_log_fuller_shortstat_s ____________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_fuller_shortstat_s>

    def test_git_log_fuller_shortstat_s(self):
        """
        Test 'git_log --format=fuller --shortstat'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_fuller_shortstat.splitlines(), quiet=True)), self.generic_git_log_fuller_shortstat_streaming_json)
E       AssertionError: Lists differ: [{'co[399 chars]1650449016, 'epoch_utc': None}, {'commit': '72[1073373 chars]one}] != [{'co[399 chars]1650474216, 'epoch_utc': None}, {'commit': '72[1073373 chars]one}]
E
E       First differing element 0:
E       {'com[365 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[365 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1355183 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:237: AssertionError
______________________ MyTests.test_git_log_fuller_stat_s ______________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_fuller_stat_s>

    def test_git_log_fuller_stat_s(self):
        """
        Test 'git_log --format=fuller --stat'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_fuller_stat.splitlines(), quiet=True)), self.generic_git_log_fuller_stat_streaming_json)
E       AssertionError: Lists differ: [{'co[592 chars]1650449016, 'epoch_utc': None}, {'commit': '72[1898357 chars]one}] != [{'co[592 chars]1650474216, 'epoch_utc': None}, {'commit': '72[1898357 chars]one}]
E
E       First differing element 0:
E       {'com[558 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[558 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 2806146 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:231: AssertionError
________________________ MyTests.test_git_log_medium_s _________________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_medium_s>

    def test_git_log_medium_s(self):
        """
        Test 'git_log --format=medium'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_medium.splitlines(), quiet=True)), self.generic_git_log_medium_streaming_json)
E       AssertionError: Lists differ: [{'co[204 chars]1650449016, 'epoch_utc': None}, {'commit': '72[614254 chars]one}] != [{'co[204 chars]1650474216, 'epoch_utc': None}, {'commit': '72[614254 chars]one}]
E
E       First differing element 0:
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 857509 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:189: AssertionError
___________________ MyTests.test_git_log_medium_shortstat_s ____________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_medium_shortstat_s>

    def test_git_log_medium_shortstat_s(self):
        """
        Test 'git_log --format=medium --shortstat'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_medium_shortstat.splitlines(), quiet=True)), self.generic_git_log_medium_shortstat_streaming_json)
E       AssertionError: Lists differ: [{'co[271 chars]1650449016, 'epoch_utc': None}, {'commit': '72[764756 chars]one}] != [{'co[271 chars]1650474216, 'epoch_utc': None}, {'commit': '72[764756 chars]one}]
E
E       First differing element 0:
E       {'com[237 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[237 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 1017242 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:201: AssertionError
______________________ MyTests.test_git_log_medium_stat_s ______________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_medium_stat_s>

    def test_git_log_medium_stat_s(self):
        """
        Test 'git_log --format=medium --stat'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log_medium_stat.splitlines(), quiet=True)), self.generic_git_log_medium_stat_streaming_json)
E       AssertionError: Lists differ: [{'co[464 chars]1650449016, 'epoch_utc': None}, {'commit': '72[1589740 chars]one}] != [{'co[464 chars]1650474216, 'epoch_utc': None}, {'commit': '72[1589740 chars]one}]
E
E       First differing element 0:
E       {'com[430 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[430 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 2468205 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:195: AssertionError
____________________________ MyTests.test_git_log_s ____________________________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_s>

    def test_git_log_s(self):
        """
        Test 'git_log'
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log.splitlines(), quiet=True)), self.generic_git_log_streaming_json)
E       AssertionError: Lists differ: [{'co[204 chars]1650449016, 'epoch_utc': None}, {'commit': '72[614254 chars]one}] != [{'co[204 chars]1650474216, 'epoch_utc': None}, {'commit': '72[614254 chars]one}]
E
E       First differing element 0:
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650449016, 'epoch_utc': None}
E       {'com[170 chars]': 'use stat examples', 'epoch': 1650474216, 'epoch_utc': None}
E
E       Diff is 857509 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:165: AssertionError
_______________ MyTests.test_git_log_s_ignore_exceptions_success _______________

self = <tests.test_git_log_s.MyTests testMethod=test_git_log_s_ignore_exceptions_success>

    def test_git_log_s_ignore_exceptions_success(self):
        """
        Test 'git log' with -qq (ignore_exceptions) option
        """
>       self.assertEqual(list(jc.parsers.git_log_s.parse(self.generic_git_log.splitlines(), quiet=True, ignore_exceptions=True)), self.generic_git_log_streaming_ignore_exceptions_json)
E       AssertionError: Lists differ: [{'co[204 chars]1650449016, 'epoch_utc': None, '_jc_meta': {'s[689677 chars]ue}}] != [{'co[204 chars]1650474216, 'epoch_utc': None, '_jc_meta': {'s[689677 chars]ue}}]
E
E       First differing element 0:
E       {'com[201 chars]: 1650449016, 'epoch_utc': None, '_jc_meta': {'success': True}}
E       {'com[201 chars]: 1650474216, 'epoch_utc': None, '_jc_meta': {'success': True}}
E
E       Diff is 942664 characters long. Set self.maxDiff to None to see it.

tests/test_git_log_s.py:151: AssertionError
_________________________ MyTests.test_utils_timestamp _________________________

self = <tests.test_jc_utils.MyTests testMethod=test_utils_timestamp>

    def test_utils_timestamp(self):
        # naive timestamps created in PDT
        datetime_map = {
            # C locale format conversion, or date cli command in C locale with non-UTC tz
            'Tue Mar 23 16:12:11 2021': {'string': 'Tue Mar 23 16:12:11 2021', 'format': 1000, 'naive': 1616541131, 'utc': None},
            'Tue Mar 23 16:12:11 IST 2021': {'string': 'Tue Mar 23 16:12:11 IST 2021', 'format': 1000, 'naive': 1616541131, 'utc': None},
            # Git date output
            'Thu Mar 5 09:17:40 2020 -0800': {'string': 'Thu Mar 5 09:17:40 2020 -0800', 'format': 1100, 'naive': 1583428660, 'utc': None},
            # ISO Format with UTC (found in syslog 5424)
            '2003-10-11T22:14:15.003Z': {'string': '2003-10-11T22:14:15.003Z', 'format': 1300, 'naive': 1065935655, 'utc': 1065910455},
            # ISO Format without TZ (found in syslog 5424)
            '2003-10-11T22:14:15.003': {'string': '2003-10-11T22:14:15.003', 'format': 1310, 'naive': 1065935655, 'utc': None},
            # CEF Format with UTC
            'Nov 08 2022 12:30:00.111 UTC': {'string': 'Nov 08 2022 12:30:00.111 UTC', 'format': 1400, 'naive': 1667939400, 'utc': 1667910600},
            # CEF Format without TZ
            'Nov 08 2022 12:30:00.111': {'string': 'Nov 08 2022 12:30:00.111', 'format': 1410, 'naive': 1667939400, 'utc': None},
            # CEF Format with UTC without microseconds
            'Nov 08 2022 12:30:00 UTC': {'string': 'Nov 08 2022 12:30:00 UTC', 'format': 1420, 'naive': 1667939400, 'utc': 1667910600},
            # CEF Format without TZ or microseconds
            'Nov 08 2022 12:30:00': {'string': 'Nov 08 2022 12:30:00', 'format': 1430, 'naive': 1667939400, 'utc': None},
            # en_US.UTF-8 local format (found in who cli output)
            '2021-03-23 00:14': {'string': '2021-03-23 00:14', 'format': 1500, 'naive': 1616483640, 'utc': None},
            # Windows english format (found in dir cli output)
            '12/07/2019 02:09 AM': {'string': '12/07/2019 02:09 AM', 'format': 1600, 'naive': 1575713340, 'utc': None},
            # Windows english format wint non-UTC tz (found in systeminfo cli output)
            '3/22/2021, 1:15:51 PM (UTC-0600)': {'string': '3/22/2021, 1:15:51 PM (UTC-0600)', 'format': 1700, 'naive': 1616444151, 'utc': None},
            # Windows english format with UTC tz (found in systeminfo cli output)
            '3/22/2021, 1:15:51 PM (UTC)': {'string': '3/22/2021, 1:15:51 PM (UTC)', 'format': 1705, 'naive': 1616444151, 'utc': 1616418951},
            # Windows english format with UTC tz in long-form (found in systeminfo cli output)
            '3/22/2021, 1:15:51 PM (Coordinated Universal Time)': {'string': '3/22/2021, 1:15:51 PM (Coordinated Universal Time)', 'format': 1705, 'naive': 1616444151, 'utc': 1616418951},
            # Windows english format with UTC tz (found in systeminfo cli output)
            '3/22/2021, 1:15:51 PM (UTC+0000)': {'string': '3/22/2021, 1:15:51 PM (UTC+0000)', 'format': 1710, 'naive': 1616444151, 'utc': 1616418951},
            # Google Big Table format with no timezone:
            '2000/01/01-01:00:00.000000': {'string': '2000/01/01-01:00:00.000000', 'format': 1750, 'naive': 946717200, 'utc': None},
            # Google Big Table format with timezone:
            '2000/01/01-01:00:00.000000+00:00': {'string': '2000/01/01-01:00:00.000000+00:00', 'format': 1755, 'naive': 946717200, 'utc': 946688400},
            # certbot format with timezone:
            '2023-05-11 01:33:10+00:00': {'string': '2023-05-11 01:33:10+00:00', 'format': 1760, 'naive': 1683793990, 'utc': 1683768790},
            # Common Log Format
            '10/Oct/2000:13:55:36 -0700': {'string': '10/Oct/2000:13:55:36 -0700', 'format': 1800, 'naive': 971211336, 'utc': None},
            '10/Oct/2000:13:55:36 -0000': {'string': '10/Oct/2000:13:55:36 -0000', 'format': 1800, 'naive': 971211336, 'utc': 971186136},
            # en_US.UTF-8 local format (found in upower cli output)
            'Tue 23 Mar 2021 04:12:11 PM UTC': {'string': 'Tue 23 Mar 2021 04:12:11 PM UTC', 'format': 2000, 'naive': 1616541131, 'utc': 1616515931},
            # en_US.UTF-8 local format with non-UTC tz (found in upower cli output)
            'Tue 23 Mar 2021 04:12:11 PM IST': {'string': 'Tue 23 Mar 2021 04:12:11 PM IST', 'format': 3000, 'naive': 1616541131, 'utc': None},
            # HTTP header time format (always GMT so assume UTC)
            'Wed, 31 Jan 2024 00:39:28 GMT': {'string': 'Wed, 31 Jan 2024 00:39:28 GMT', 'format': 3500, 'naive': 1706690368, 'utc': 1706661568},
            # European local format (found in upower cli output)
            'Tuesday 01 October 2019 12:50:41 PM UTC': {'string': 'Tuesday 01 October 2019 12:50:41 PM UTC', 'format': 4000, 'naive': 1569959441, 'utc': 1569934241},
            # European local format with non-UTC tz (found in upower cli output)
            'Tuesday 01 October 2019 12:50:41 PM IST': {'string': 'Tuesday 01 October 2019 12:50:41 PM IST', 'format': 5000, 'naive': 1569959441, 'utc': None},
            # date cli command in en_US.UTF-8 format
            'Wed Mar 24 06:16:19 PM UTC 2021': {'string': 'Wed Mar 24 06:16:19 PM UTC 2021', 'format': 6000, 'naive': 1616634979, 'utc': 1616609779},
            # date cli command in C locale format
            'Wed Mar 24 11:11:30 UTC 2021': {'string': 'Wed Mar 24 11:11:30 UTC 2021', 'format': 7000, 'naive': 1616609490, 'utc': 1616584290},
            # C locale format (found in stat cli output - OSX)
            'Mar 29 11:49:05 2021': {'string': 'Mar 29 11:49:05 2021', 'format': 7100, 'naive': 1617043745, 'utc': None},
            # C local format (found in stat cli output - linux) non-UTC tz
            '2019-08-13 18:13:43.555604315 -0400': {'string': '2019-08-13 18:13:43.555604315 -0400', 'format': 7200, 'naive': 1565745223, 'utc': None},
            # C local format (found in stat cli output - linux) UTC
            '2019-08-13 18:13:43.555604315 -0000': {'string': '2019-08-13 18:13:43.555604315 -0000', 'format': 7200, 'naive': 1565745223, 'utc': 1565720023},
            # C locale format with non-UTC tz (found in modified vmstat cli output)
            '2021-09-16 20:32:28 PDT': {'string': '2021-09-16 20:32:28 PDT', 'format': 7250, 'naive': 1631849548, 'utc': None},
            # C locale format (found in modified vmstat cli output)
            '2021-09-16 20:32:28 UTC': {'string': '2021-09-16 20:32:28 UTC', 'format': 7255, 'naive': 1631849548, 'utc': 1631824348},
            # C locale format (found in timedatectl cli output)
            'Wed 2020-03-11 00:53:21 UTC': {'string': 'Wed 2020-03-11 00:53:21 UTC', 'format': 7300, 'naive': 1583913201, 'utc': 1583888001},
            # test with None input
            None: {'string': None, 'format': None, 'naive': None, 'utc': None}
        }

        # fixup for change in behavior after python 3.6:
        # Changed in version 3.7: When the %z directive is provided to the strptime() method,
        # the UTC offsets can have a colon as a separator between hours, minutes and seconds.
        # For example, '+01:00:00' will be parsed as an offset of one hour. In addition,
        # providing 'Z' is identical to '+00:00'.
        if sys.version_info < (3, 7, 0):
            del datetime_map['2000/01/01-01:00:00.000000+00:00']

        for input_string, expected_output in datetime_map.items():
            ts = jc.utils.timestamp(input_string)
            ts_dict = {
                'string': ts.string,
                'format': ts.format,
                'naive': ts.naive,
                'utc': ts.utc
            }

>           self.assertEqual(ts_dict, expected_output)
E           AssertionError: {'str[20 chars]:12:11 2021', 'format': 1000, 'naive': 1616515931, 'utc': None} != {'str[20 chars]:12:11 2021', 'format': 1000, 'naive': 1616541131, 'utc': None}
E             {'format': 1000,
E           -  'naive': 1616515931,
E           ?                 ^^
E
E           +  'naive': 1616541131,
E           ?                + ^
E
E              'string': 'Tue Mar 23 16:12:11 2021',
E              'utc': None}

tests/test_jc_utils.py:96: AssertionError
_______________________ MyTests.test_last_F_ubuntu_20_4 ________________________

self = <tests.test_last.MyTests testMethod=test_last_F_ubuntu_20_4>

    def test_last_F_ubuntu_20_4(self):
        """
        Test 'last -F' on Ubuntu 20.4
        """
>       self.assertEqual(jc.parsers.last.parse(self.ubuntu_20_4_last_F, quiet=True), self.ubuntu_20_4_last_F_json)
E       AssertionError: Lists differ: [{'us[139 chars] 1609877031}, {'user': 'kbrazil', 'tty': 'pts/[677 chars]308}] != [{'us[139 chars] 1609905831}, {'user': 'kbrazil', 'tty': 'pts/[677 chars]108}]
E
E       First differing element 0:
E       {'use[87 chars] 2021', 'logout': 'still logged in', 'login_epoch': 1609877031}
E       {'use[87 chars] 2021', 'logout': 'still logged in', 'login_epoch': 1609905831}
E
E       Diff is 1536 characters long. Set self.maxDiff to None to see it.

tests/test_last.py:144: AssertionError
_______________________ MyTests.test_last_wF_centos_7_7 ________________________

self = <tests.test_last.MyTests testMethod=test_last_wF_centos_7_7>

    def test_last_wF_centos_7_7(self):
        """
        Test 'last -wF' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.last.parse(self.centos_7_7_last_wF, quiet=True), self.centos_7_7_last_wF_json)
E       AssertionError: Lists differ: [{'us[152 chars]1609856964}, {'user': 'kbrazil', 'tty': 'tty1'[39910 chars]849}] != [{'us[152 chars]1609885764}, {'user': 'kbrazil', 'tty': 'tty1'[39910 chars]849}]
E
E       First differing element 0:
E       {'use[99 chars] 2021', 'logout': 'still logged in', 'login_epoch': 1609856964}
E       {'use[99 chars] 2021', 'logout': 'still logged in', 'login_epoch': 1609885764}
E
E       Diff is 75034 characters long. Set self.maxDiff to None to see it.

tests/test_last.py:168: AssertionError
______________________ MyTests.test_last_wixF_centos_7_7 _______________________

self = <tests.test_last.MyTests testMethod=test_last_wixF_centos_7_7>

    def test_last_wixF_centos_7_7(self):
        """
        Test 'last -wixF' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.last.parse(self.centos_7_7_last_wixF, quiet=True), self.centos_7_7_last_wixF_json)
E       AssertionError: Lists differ: [{'us[138 chars] 1687184293}, {'user': 'mark', 'tty': 'pts/0',[1318 chars] 26}] != [{'us[138 chars] 1687209493}, {'user': 'mark', 'tty': 'pts/0',[1318 chars] 26}]
E
E       First differing element 0:
E       {'use[86 chars] 2023', 'logout': 'still logged in', 'login_epoch': 1687184293}
E       {'use[86 chars] 2023', 'logout': 'still logged in', 'login_epoch': 1687209493}
E
E       Diff is 2812 characters long. Set self.maxDiff to None to see it.

tests/test_last.py:174: AssertionError
______________________ MyTests.test_ls_l_iso_ubuntu_18_4 _______________________

self = <tests.test_ls.MyTests testMethod=test_ls_l_iso_ubuntu_18_4>

    def test_ls_l_iso_ubuntu_18_4(self):
        """
        Test 'ls -l --time-style=full-iso' for files with convertible dates on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.ls.parse(self.ubuntu_18_4_ls_l_iso, quiet=True), self.ubuntu_18_4_ls_l_iso_json)
E       AssertionError: Lists differ: [{'fi[154 chars]1516239829, 'epoch_utc': None}, {'filename': '[179968 chars]one}] != [{'fi[154 chars]1516268629, 'epoch_utc': None}, {'filename': '[179968 chars]one}]
E
E       First differing element 0:
E       {'fil[120 chars]43:49.000000000 -0800', 'epoch': 1516239829, 'epoch_utc': None}
E       {'fil[120 chars]43:49.000000000 -0800', 'epoch': 1516268629, 'epoch_utc': None}
E
E       Diff is 274071 characters long. Set self.maxDiff to None to see it.

tests/test_ls.py:438: AssertionError
_____________________ MyTests.test_ls_s_l_iso_ubuntu_18_4 ______________________

self = <tests.test_ls_s.MyTests testMethod=test_ls_s_l_iso_ubuntu_18_4>

    def test_ls_s_l_iso_ubuntu_18_4(self):
        """
        Test 'ls -l --time-style=full-iso' for files with convertible dates on Ubuntu 18.4
        """
>       self.assertEqual(list(jc.parsers.ls_s.parse(self.ubuntu_18_4_ls_l_iso.splitlines(), quiet=True)), self.ubuntu_18_4_ls_l_iso_streaming_json)
E       AssertionError: Lists differ: [{'fi[154 chars]1516239829, 'epoch_utc': None}, {'filename': '[179966 chars]one}] != [{'fi[154 chars]1516268629, 'epoch_utc': None}, {'filename': '[179966 chars]one}]
E
E       First differing element 0:
E       {'fil[120 chars]43:49.000000000 -0800', 'epoch': 1516239829, 'epoch_utc': None}
E       {'fil[120 chars]43:49.000000000 -0800', 'epoch': 1516268629, 'epoch_utc': None}
E
E       Diff is 274069 characters long. Set self.maxDiff to None to see it.

tests/test_ls_s.py:172: AssertionError
__________________________ MyTests.test_mdadm_examine __________________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine>

    def test_mdadm_examine(self):
        """
        Test 'mdadm --examine'
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine, quiet=True), self.mdadm_examine_json)
E       AssertionError: {'dev[1126 chars]ation_time_epoch': 1271200936, 'update_time_epoch': 1658866591} != {'dev[1126 chars]ation_time_epoch': 1271226136, 'update_time_epoch': 1658891791}
E       Diff is 1513 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:356: AssertionError
___________________ MyTests.test_mdadm_examine_raid0_offline ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid0_offline>

    def test_mdadm_examine_raid0_offline(self):
        """
        Test 'mdadm --examine' with offline RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid0_offline, quiet=True), self.mdadm_examine_raid0_offline_json)
E       AssertionError: {'dev[1081 chars]ation_time_epoch': 1659905812, 'update_time_epoch': 1659905812} != {'dev[1081 chars]ation_time_epoch': 1659931012, 'update_time_epoch': 1659931012}
E       Diff is 1466 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:265: AssertionError
_____________________ MyTests.test_mdadm_examine_raid0_ok ______________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid0_ok>

    def test_mdadm_examine_raid0_ok(self):
        """
        Test 'mdadm --examine' with ok RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid0_ok, quiet=True), self.mdadm_examine_raid0_ok_json)
E       AssertionError: {'dev[1081 chars]ation_time_epoch': 1659905812, 'update_time_epoch': 1659905812} != {'dev[1081 chars]ation_time_epoch': 1659931012, 'update_time_epoch': 1659931012}
E       Diff is 1466 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:272: AssertionError
___________________ MyTests.test_mdadm_examine_raid1_0_90_ok ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_0_90_ok>

    def test_mdadm_examine_raid1_0_90_ok(self):
        """
        Test 'mdadm --examine' with ok RAID array v0.90
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_0_90_ok, quiet=True), self.mdadm_examine_raid1_0_90_ok_json)
E       AssertionError: {'dev[1141 chars]ation_time_epoch': 1659909176, 'update_time_epoch': 1659909275} != {'dev[1141 chars]ation_time_epoch': 1659934376, 'update_time_epoch': 1659934475}
E       Diff is 1868 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:279: AssertionError
__________________ MyTests.test_mdadm_examine_raid1_checking ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_checking>

    def test_mdadm_examine_raid1_checking(self):
        """
        Test 'mdadm --examine' with checking RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_checking, quiet=True), self.mdadm_examine_raid1_checking_json)
E       AssertionError: {'dev[1104 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907439} != {'dev[1104 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932639}
E       Diff is 1709 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:286: AssertionError
__________________ MyTests.test_mdadm_examine_raid1_failfast ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_failfast>

    def test_mdadm_examine_raid1_failfast(self):
        """
        Test 'mdadm --examine' with failfast RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_failfast, quiet=True), self.mdadm_examine_raid1_failfast_json)
E       AssertionError: {'dev[1167 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908254} != {'dev[1167 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933454}
E       Diff is 1560 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:293: AssertionError
___________________ MyTests.test_mdadm_examine_raid1_faulty1 ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_faulty1>

    def test_mdadm_examine_raid1_faulty1(self):
        """
        Test 'mdadm --examine' with faulty RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_faulty1, quiet=True), self.mdadm_examine_raid1_faulty1_json)
E       AssertionError: {'dev[1120 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907714} != {'dev[1120 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932914}
E       Diff is 1507 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:300: AssertionError
___________________ MyTests.test_mdadm_examine_raid1_faulty2 ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_faulty2>

    def test_mdadm_examine_raid1_faulty2(self):
        """
        Test 'mdadm --examine' with faulty RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_faulty2, quiet=True), self.mdadm_examine_raid1_faulty2_json)
E       AssertionError: {'dev[1119 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907622} != {'dev[1119 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932822}
E       Diff is 1506 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:307: AssertionError
__________________ MyTests.test_mdadm_examine_raid1_moreflags __________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_moreflags>

    def test_mdadm_examine_raid1_moreflags(self):
        """
        Test 'mdadm --examine' with RAID array with several flags
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_moreflags, quiet=True), self.mdadm_examine_raid1_moreflags_json)
E       AssertionError: {'dev[1196 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908938} != {'dev[1196 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659934138}
E       Diff is 1589 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:314: AssertionError
_____________________ MyTests.test_mdadm_examine_raid1_ok ______________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_ok>

    def test_mdadm_examine_raid1_ok(self):
        """
        Test 'mdadm --examine' with ok RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_ok, quiet=True), self.mdadm_examine_raid1_ok_json)
E       AssertionError: {'dev[1119 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907208} != {'dev[1119 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932408}
E       Diff is 1505 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:321: AssertionError
__________________ MyTests.test_mdadm_examine_raid1_replacing __________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_replacing>

    def test_mdadm_examine_raid1_replacing(self):
        """
        Test 'mdadm --examine' with replacing RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_replacing, quiet=True), self.mdadm_examine_raid1_replacing_json)
E       AssertionError: {'dev[1242 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908895} != {'dev[1242 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659934095}
E       Diff is 1637 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:328: AssertionError
___________________ MyTests.test_mdadm_examine_raid1_resync ____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_resync>

    def test_mdadm_examine_raid1_resync(self):
        """
        Test 'mdadm --examine' with resyncing RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_resync, quiet=True), self.mdadm_examine_raid1_resync_json)
E       AssertionError: {'dev[1108 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907552} != {'dev[1108 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932752}
E       Diff is 1712 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:335: AssertionError
____________________ MyTests.test_mdadm_examine_raid1_spare ____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_spare>

    def test_mdadm_examine_raid1_spare(self):
        """
        Test 'mdadm --examine' with spare in RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_spare, quiet=True), self.mdadm_examine_raid1_spare_json)
E       AssertionError: {'dev[1109 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908398} != {'dev[1109 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933598}
E       Diff is 1495 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:342: AssertionError
___________________ MyTests.test_mdadm_examine_raid1_syncing ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid1_syncing>

    def test_mdadm_examine_raid1_syncing(self):
        """
        Test 'mdadm --examine' with syncing RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid1_syncing, quiet=True), self.mdadm_examine_raid1_syncing_json)
E       AssertionError: {'dev[1119 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659906949} != {'dev[1119 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932149}
E       Diff is 1506 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:349: AssertionError
__________________ MyTests.test_mdadm_examine_raid5_homehost ___________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid5_homehost>

    def test_mdadm_examine_raid5_homehost(self):
        """
        Test 'mdadm --examine' on RAID5 homehost
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid5_homehost, quiet=True), self.mdadm_examine_raid5_homehost_json)
E       AssertionError: {'dev[1145 chars]ation_time_epoch': 1660669321, 'update_time_epoch': 1660669325} != {'dev[1145 chars]ation_time_epoch': 1660694521, 'update_time_epoch': 1660694525}
E       Diff is 1538 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:475: AssertionError
___________________ MyTests.test_mdadm_examine_raid5_meta09 ____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid5_meta09>

    def test_mdadm_examine_raid5_meta09(self):
        """
        Test 'mdadm --examine' on RAID5 on v0.9
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid5_meta09, quiet=True), self.mdadm_examine_raid5_meta09_json)
E       AssertionError: {'dev[1328 chars]ation_time_epoch': 1660669502, 'update_time_epoch': 1660669506} != {'dev[1328 chars]ation_time_epoch': 1660694702, 'update_time_epoch': 1660694706}
E       Diff is 2189 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:482: AssertionError
_____________________ MyTests.test_mdadm_examine_raid5_ok ______________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_examine_raid5_ok>

    def test_mdadm_examine_raid5_ok(self):
        """
        Test 'mdadm --examine' on ok RAID5
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_examine_raid5_ok, quiet=True), self.mdadm_examine_raid5_ok_json)
E       AssertionError: {'dev[1201 chars]ation_time_epoch': 1660669174, 'update_time_epoch': 1660669179} != {'dev[1201 chars]ation_time_epoch': 1660694374, 'update_time_epoch': 1660694379}
E       Diff is 1597 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:489: AssertionError
_______________________ MyTests.test_mdadm_query_detail ________________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_detail>

    def test_mdadm_query_detail(self):
        """
        Test 'mdadm --query --detail'
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_detail, quiet=True), self.mdadm_query_detail_json)
E       AssertionError: {'dev[1009 chars]ation_time_epoch': 1271200936, 'update_time_epoch': 1658866591} != {'dev[1009 chars]ation_time_epoch': 1271226136, 'update_time_epoch': 1658891791}
E       Diff is 1608 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:363: AssertionError
______________________ MyTests.test_mdadm_query_raid0_ok _______________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid0_ok>

    def test_mdadm_query_raid0_ok(self):
        """
        Test 'mdadm --query' on ok RAID array
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid0_ok, quiet=True), self.mdadm_query_raid0_ok_json)
E       AssertionError: {'dev[1003 chars]ation_time_epoch': 1659905812, 'update_time_epoch': 1659905812} != {'dev[1003 chars]ation_time_epoch': 1659931012, 'update_time_epoch': 1659931012}
E       Diff is 1603 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:370: AssertionError
_______________ MyTests.test_mdadm_query_raid1_failed_and_flags ________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_failed_and_flags>

    def test_mdadm_query_raid1_failed_and_flags(self):
        """
        Test 'mdadm --query' on failed RAID array with flags
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_failed_and_flags, quiet=True), self.mdadm_query_raid1_failed_and_flags_json)
E       AssertionError: {'dev[1155 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908938} != {'dev[1155 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659934138}
E       Diff is 1879 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:377: AssertionError
____________________ MyTests.test_mdadm_query_raid1_faulty _____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_faulty>

    def test_mdadm_query_raid1_faulty(self):
        """
        Test 'mdadm --query' on faulty RAID
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_faulty, quiet=True), self.mdadm_query_raid1_faulty_json)
E       AssertionError: {'dev[1137 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907714} != {'dev[1137 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932914}
E       Diff is 1861 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:398: AssertionError
______________ MyTests.test_mdadm_query_raid1_faulty_and_removed _______________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_faulty_and_removed>

    def test_mdadm_query_raid1_faulty_and_removed(self):
        """
        Test 'mdadm --query' on faulty RAID array with removed disk
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_faulty_and_removed, quiet=True), self.mdadm_query_raid1_faulty_and_removed_json)
E       AssertionError: {'dev[1031 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907947} != {'dev[1031 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933147}
E       Diff is 1630 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:384: AssertionError
_______________ MyTests.test_mdadm_query_raid1_faulty_with_spare _______________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_faulty_with_spare>

    def test_mdadm_query_raid1_faulty_with_spare(self):
        """
        Test 'mdadm --query' on faulty RAID array with spare disk
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_faulty_with_spare, quiet=True), self.mdadm_query_raid1_faulty_with_spare_json)
E       AssertionError: {'dev[1257 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908598} != {'dev[1257 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933798}
E       Diff is 1987 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:391: AssertionError
______________________ MyTests.test_mdadm_query_raid1_ok _______________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_ok>

    def test_mdadm_query_raid1_ok(self):
        """
        Test 'mdadm --query' on ok RAID
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_ok, quiet=True), self.mdadm_query_raid1_ok_json)
E       AssertionError: {'dev[1022 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659907208} != {'dev[1022 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932408}
E       Diff is 1620 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:426: AssertionError
____________________ MyTests.test_mdadm_query_raid1_ok_0_9 _____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_ok_0_9>

    def test_mdadm_query_raid1_ok_0_9(self):
        """
        Test 'mdadm --query' on ok RAID on v0.9
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_ok_0_9, quiet=True), self.mdadm_query_raid1_ok_0_9_json)
E       AssertionError: {'dev[1007 chars]ation_time_epoch': 1659909176, 'update_time_epoch': 1659909275} != {'dev[1007 chars]ation_time_epoch': 1659934376, 'update_time_epoch': 1659934475}
E       Diff is 1606 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:405: AssertionError
__________________ MyTests.test_mdadm_query_raid1_ok_failfast __________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_ok_failfast>

    def test_mdadm_query_raid1_ok_failfast(self):
        """
        Test 'mdadm --query' on ok RAID with failfast
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_ok_failfast, quiet=True), self.mdadm_query_raid1_ok_failfast_json)
E       AssertionError: {'dev[1034 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908254} != {'dev[1034 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933454}
E       Diff is 1633 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:412: AssertionError
___________________ MyTests.test_mdadm_query_raid1_ok_spare ____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_ok_spare>

    def test_mdadm_query_raid1_ok_spare(self):
        """
        Test 'mdadm --query' on ok RAID with spare
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_ok_spare, quiet=True), self.mdadm_query_raid1_ok_spare_json)
E       AssertionError: {'dev[1139 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908398} != {'dev[1139 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933598}
E       Diff is 1862 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:419: AssertionError
_______________ MyTests.test_mdadm_query_raid1_rebuild_failfast ________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_rebuild_failfast>

    def test_mdadm_query_raid1_rebuild_failfast(self):
        """
        Test 'mdadm --query' on rebuilding RAID with failfast
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_rebuild_failfast, quiet=True), self.mdadm_query_raid1_rebuild_failfast_json)
E       AssertionError: {'dev[1151 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908177} != {'dev[1151 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659933377}
E       Diff is 1756 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:433: AssertionError
_____________ MyTests.test_mdadm_query_raid1_spare_writem_rebuild ______________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_spare_writem_rebuild>

    def test_mdadm_query_raid1_spare_writem_rebuild(self):
        """
        Test 'mdadm --query' on rebuilding RAID with spare
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_spare_writem_rebuild, quiet=True), self.mdadm_query_raid1_spare_writem_rebuild_json)
E       AssertionError: {'dev[1255 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659908862} != {'dev[1255 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659934062}
E       Diff is 1984 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:440: AssertionError
____________________ MyTests.test_mdadm_query_raid1_syncing ____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid1_syncing>

    def test_mdadm_query_raid1_syncing(self):
        """
        Test 'mdadm --query' on syncing RAID
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid1_syncing, quiet=True), self.mdadm_query_raid1_syncing_json)
E       AssertionError: {'dev[1104 chars]ation_time_epoch': 1659906949, 'update_time_epoch': 1659906949} != {'dev[1104 chars]ation_time_epoch': 1659932149, 'update_time_epoch': 1659932149}
E       Diff is 1709 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:447: AssertionError
___________________ MyTests.test_mdadm_query_raid5_homehost ____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid5_homehost>

    def test_mdadm_query_raid5_homehost(self):
        """
        Test 'mdadm --query' RAID5 with homehost
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid5_homehost, quiet=True), self.mdadm_query_raid5_homehost_json)
E       AssertionError: {'dev[1146 chars]ation_time_epoch': 1660669321, 'update_time_epoch': 1660669325} != {'dev[1146 chars]ation_time_epoch': 1660694521, 'update_time_epoch': 1660694525}
E       Diff is 1876 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:524: AssertionError
____________________ MyTests.test_mdadm_query_raid5_meta09 _____________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid5_meta09>

    def test_mdadm_query_raid5_meta09(self):
        """
        Test 'mdadm --query' RAID5 on v0.9
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid5_meta09, quiet=True), self.mdadm_query_raid5_meta09_json)
E       AssertionError: {'dev[1193 chars]ation_time_epoch': 1660669502, 'update_time_epoch': 1660669506} != {'dev[1193 chars]ation_time_epoch': 1660694702, 'update_time_epoch': 1660694706}
E       Diff is 1926 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:531: AssertionError
______________________ MyTests.test_mdadm_query_raid5_ok _______________________

self = <tests.test_mdadm.MyTests testMethod=test_mdadm_query_raid5_ok>

    def test_mdadm_query_raid5_ok(self):
        """
        Test 'mdadm --query' on ok RAID5
        """
>       self.assertEqual(jc.parsers.mdadm.parse(self.mdadm_query_raid5_ok, quiet=True), self.mdadm_query_raid5_ok_json)
E       AssertionError: {'dev[1202 chars]ation_time_epoch': 1660669174, 'update_time_epoch': 1660669179} != {'dev[1202 chars]ation_time_epoch': 1660694374, 'update_time_epoch': 1660694379}
E       Diff is 1935 characters long. Set self.maxDiff to None to see it.

tests/test_mdadm.py:538: AssertionError
_____________________________ MyTests.test_openvpn _____________________________

self = <tests.test_openvpn.MyTests testMethod=test_openvpn>

    def test_openvpn(self):
        """
        Test 'openvpn'
        """
>       self.assertEqual(
            parse(self.f_in['openvpn'], quiet=True),
            self.f_json['openvpn']
        )
E       AssertionError: {'cli[291 chars]1434601383, 'updated_epoch': 1434615135}, {'co[5026 chars]: 0}} != {'cli[291 chars]1434626583, 'updated_epoch': 1434640335}, {'co[5026 chars]: 0}}
E       Diff is 12057 characters long. Set self.maxDiff to None to see it.

tests/test_openvpn.py:40: AssertionError
_______________________ MyTests.test_plist_bin_alltypes ________________________

self = <tests.test_plist.MyTests testMethod=test_plist_bin_alltypes>

    def test_plist_bin_alltypes(self):
        """
        Test binary plist file with all object types
        """
>       self.assertEqual(jc.parsers.plist.parse(self.generic_alltypes_bin, quiet=True), self.generic_alltypes_bin_json)
E       AssertionError: {'aDate': 1659344551, 'aDict': {'aFalseValue': False, 'a[922 chars]281'} != {'aDate': 1659369751, 'aDict': {'aFalseValue': False, 'a[922 chars]281'}
E       Diff is 1117 characters long. Set self.maxDiff to None to see it.

tests/test_plist.py:82: AssertionError
_______________________ MyTests.test_plist_xml_alltypes ________________________

self = <tests.test_plist.MyTests testMethod=test_plist_xml_alltypes>

    def test_plist_xml_alltypes(self):
        """
        Test XML plist file with all object types
        """
>       self.assertEqual(jc.parsers.plist.parse(self.generic_alltypes, quiet=True), self.generic_alltypes_json)
E       AssertionError: {'aDate': 1659285270, 'aDict': {'aFalseValue': False, '[916 chars]:30'} != {'aDate': 1659310470, 'aDict': {'aFalseValue': False, '[916 chars]:30'}
E       Diff is 1110 characters long. Set self.maxDiff to None to see it.

tests/test_plist.py:75: AssertionError
_______________________ MyTests.test_rpm_qai_centos_7_7 ________________________

self = <tests.test_rpm_qai.MyTests testMethod=test_rpm_qai_centos_7_7>

    def test_rpm_qai_centos_7_7(self):
        """
        Test 'rpm -qai' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.rpm_qi.parse(self.centos_7_7_rpm_qai, quiet=True), self.centos_7_7_rpm_qai_json)
E       AssertionError: Lists differ: [{'na[1038 chars] 1565286445, 'build_epoch_utc': None, 'install[462789 chars]one}] != [{'na[1038 chars] 1565311645, 'build_epoch_utc': None, 'install[462789 chars]one}]
E
E       First differing element 0:
E       {'nam[1037 chars] 1565286445, 'build_epoch_utc': None, 'install[52 chars]None}
E       {'nam[1037 chars] 1565311645, 'build_epoch_utc': None, 'install[52 chars]None}
E
E       Diff is 636319 characters long. Set self.maxDiff to None to see it.

tests/test_rpm_qai.py:36: AssertionError
____________________ MyTests.test_rpm_qi_package_centos_7_7 ____________________

self = <tests.test_rpm_qai.MyTests testMethod=test_rpm_qi_package_centos_7_7>

    def test_rpm_qi_package_centos_7_7(self):
        """
        Test 'rpm -qi make' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.rpm_qi.parse(self.centos_7_7_rpm_qi_package, quiet=True), self.centos_7_7_rpm_qi_package_json)
E       AssertionError: Lists differ: [{'na[1038 chars] 1565286445, 'build_epoch_utc': None, 'install[53 chars]one}] != [{'na[1038 chars] 1565311645, 'build_epoch_utc': None, 'install[53 chars]one}]
E
E       First differing element 0:
E       {'nam[1037 chars] 1565286445, 'build_epoch_utc': None, 'install[52 chars]None}
E       {'nam[1037 chars] 1565311645, 'build_epoch_utc': None, 'install[52 chars]None}
E
E       Diff is 1588 characters long. Set self.maxDiff to None to see it.

tests/test_rpm_qai.py:42: AssertionError
________________ MyTests.test_rsync_centos_7_7_rsync_i_logfile _________________

self = <tests.test_rsync.MyTests testMethod=test_rsync_centos_7_7_rsync_i_logfile>

    def test_rsync_centos_7_7_rsync_i_logfile(self):
        """
        Test 'rsync -i --log-file=xxx' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.rsync.parse(self.centos_7_7_rsync_i_logfile, quiet=True), self.centos_7_7_rsync_i_logfile_json)
E       AssertionError: Lists differ: [{'su[546 chars]1643342032}, {'filename': 'a.txt', 'date': '20[22892 chars]0}]}] != [{'su[546 chars]1643370832}, {'filename': 'a.txt', 'date': '20[22892 chars]0}]}]
E
E       First differing element 0:
E       {'sum[545 chars]1643342032}, {'filename': 'a.txt', 'date': '20[11144 chars]32}]}
E       {'sum[545 chars]1643370832}, {'filename': 'a.txt', 'date': '20[11144 chars]32}]}
E
E       Diff is 42135 characters long. Set self.maxDiff to None to see it.

tests/test_rsync.py:132: AssertionError
_______________ MyTests.test_rsync_centos_7_7_rsync_i_v_logfile ________________

self = <tests.test_rsync.MyTests testMethod=test_rsync_centos_7_7_rsync_i_v_logfile>

    def test_rsync_centos_7_7_rsync_i_v_logfile(self):
        """
        Test 'rsync -iv --log-file=xxx' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.rsync.parse(self.centos_7_7_rsync_i_v_logfile, quiet=True), self.centos_7_7_rsync_i_v_logfile_json)
E       AssertionError: Lists differ: [{'su[525 chars]1643343730}, {'filename': 'a.txt', 'date': '20[22898 chars]1}]}] != [{'su[525 chars]1643372530}, {'filename': 'a.txt', 'date': '20[22898 chars]1}]}]
E
E       First differing element 0:
E       {'sum[524 chars]1643343730}, {'filename': 'a.txt', 'date': '20[11144 chars]30}]}
E       {'sum[524 chars]1643372530}, {'filename': 'a.txt', 'date': '20[11144 chars]30}]}
E
E       Diff is 42034 characters long. Set self.maxDiff to None to see it.

tests/test_rsync.py:138: AssertionError
_______________ MyTests.test_rsync_centos_7_7_rsync_i_vv_logfile _______________

self = <tests.test_rsync.MyTests testMethod=test_rsync_centos_7_7_rsync_i_vv_logfile>

    def test_rsync_centos_7_7_rsync_i_vv_logfile(self):
        """
        Test 'rsync -ivv --log-file=xxx' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.rsync.parse(self.centos_7_7_rsync_i_vv_logfile, quiet=True), self.centos_7_7_rsync_i_vv_logfile_json)
E       AssertionError: Lists differ: [{'su[645 chars]1643344654}, {'filename': 'a.txt', 'date': '20[23019 chars]5}]}] != [{'su[645 chars]1643373454}, {'filename': 'a.txt', 'date': '20[23019 chars]5}]}]
E
E       First differing element 0:
E       {'sum[644 chars]1643344654}, {'filename': 'a.txt', 'date': '20[11144 chars]54}]}
E       {'sum[644 chars]1643373454}, {'filename': 'a.txt', 'date': '20[11144 chars]54}]}
E
E       Diff is 42526 characters long. Set self.maxDiff to None to see it.

tests/test_rsync.py:144: AssertionError
______________ MyTests.test_rsync_centos_7_7_rsync_i_vvv_logfile _______________

self = <tests.test_rsync.MyTests testMethod=test_rsync_centos_7_7_rsync_i_vvv_logfile>

    def test_rsync_centos_7_7_rsync_i_vvv_logfile(self):
        """
        Test 'rsync -ivvv --log-file=xxx' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.rsync.parse(self.centos_7_7_rsync_i_vvv_logfile, quiet=True), self.centos_7_7_rsync_i_vvv_logfile_json)
E       AssertionError: Lists differ: [{'su[648 chars]1643345427}, {'filename': 'a.txt', 'date': '20[35372 chars]7}]}] != [{'su[648 chars]1643374227}, {'filename': 'a.txt', 'date': '20[35372 chars]7}]}]
E
E       First differing element 0:
E       {'sum[647 chars]1643345427}, {'filename': 'a.txt', 'date': '20[11144 chars]27}]}
E       {'sum[647 chars]1643374227}, {'filename': 'a.txt', 'date': '20[11144 chars]27}]}
E
E       Diff is 64681 characters long. Set self.maxDiff to None to see it.

tests/test_rsync.py:150: AssertionError
__________ MyTests.test_rsync_centos_7_7_rsync_i_vvv_logfile_nochange __________

self = <tests.test_rsync.MyTests testMethod=test_rsync_centos_7_7_rsync_i_vvv_logfile_nochange>

    def test_rsync_centos_7_7_rsync_i_vvv_logfile_nochange(self):
        """
        Test 'rsync -ivvv --log-file=xxx' on Centos 7.7 with no file changes
        """
>       self.assertEqual(jc.parsers.rsync.parse(self.centos_7_7_rsync_i_vvv_logfile_nochange, quiet=True), self.centos_7_7_rsync_i_vvv_logfile_nochange_json)
E       AssertionError: Lists differ: [{'su[669 chars]1643440289}, {'filename': 'a.txt', 'date': '20[23887 chars]3}]}] != [{'su[669 chars]1643469089}, {'filename': 'a.txt', 'date': '20[23887 chars]3}]}]
E
E       First differing element 0:
E       {'sum[668 chars]1643440289}, {'filename': 'a.txt', 'date': '20[11623 chars]91}]}
E       {'sum[668 chars]1643469089}, {'filename': 'a.txt', 'date': '20[11623 chars]91}]}
E
E       Diff is 44102 characters long. Set self.maxDiff to None to see it.

tests/test_rsync.py:156: AssertionError
_________ MyTests.test_rsync_osx_10_14_6_rsync_i_vvv_logfile_nochange __________

self = <tests.test_rsync.MyTests testMethod=test_rsync_osx_10_14_6_rsync_i_vvv_logfile_nochange>

    def test_rsync_osx_10_14_6_rsync_i_vvv_logfile_nochange(self):
        """
        Test 'rsync -ivvv --log-file=xxx' on OSX 10.14.6 with no file changes
        """
>       self.assertEqual(jc.parsers.rsync.parse(self.osx_10_14_6_rsync_i_vvv_logfile_nochange, quiet=True), self.osx_10_14_6_rsync_i_vvv_logfile_nochange_json)
E       AssertionError: Lists differ: [{'su[479 chars]1643702966}, {'filename': 'a.txt', 'date': '20[10778 chars]7}]}] != [{'su[479 chars]1643731766}, {'filename': 'a.txt', 'date': '20[10778 chars]7}]}]
E
E       First differing element 0:
E       {'sum[478 chars]1643702966}, {'filename': 'a.txt', 'date': '20[3239 chars]66}]}
E       {'sum[478 chars]1643731766}, {'filename': 'a.txt', 'date': '20[3239 chars]66}]}
E
E       Diff is 20912 characters long. Set self.maxDiff to None to see it.

tests/test_rsync.py:162: AssertionError
__________________ MyTests.test_rsync_s_i_logfile_centos_7_7 ___________________

self = <tests.test_rsync_s.MyTests testMethod=test_rsync_s_i_logfile_centos_7_7>

    def test_rsync_s_i_logfile_centos_7_7(self):
        """
        Test 'rsync -i --logfile=xxx' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.rsync_s.parse(self.centos_7_7_rsync_i_logfile.splitlines(), quiet=True)), self.centos_7_7_rsync_i_logfile_streaming_json)
E       AssertionError: Lists differ: [{'ty[429 chars]1643342032}, {'type': 'file', 'filename': 'a.t[23758 chars]100}] != [{'ty[429 chars]1643370832}, {'type': 'file', 'filename': 'a.t[23758 chars]900}]
E
E       First differing element 0:
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643342032}
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643370832}
E
E       Diff is 31773 characters long. Set self.maxDiff to None to see it.

tests/test_rsync_s.py:136: AssertionError
_________________ MyTests.test_rsync_s_i_v_logfile_centos_7_7 __________________

self = <tests.test_rsync_s.MyTests testMethod=test_rsync_s_i_v_logfile_centos_7_7>

    def test_rsync_s_i_v_logfile_centos_7_7(self):
        """
        Test 'rsync -iv --logfile=xxx' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.rsync_s.parse(self.centos_7_7_rsync_i_v_logfile.splitlines(), quiet=True)), self.centos_7_7_rsync_i_v_logfile_streaming_json)
E       AssertionError: Lists differ: [{'ty[429 chars]1643343730}, {'type': 'file', 'filename': 'a.t[23724 chars].11}] != [{'ty[429 chars]1643372530}, {'type': 'file', 'filename': 'a.t[23724 chars].11}]
E
E       First differing element 0:
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643343730}
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643372530}
E
E       Diff is 31602 characters long. Set self.maxDiff to None to see it.

tests/test_rsync_s.py:142: AssertionError
_________________ MyTests.test_rsync_s_i_vv_logfile_centos_7_7 _________________

self = <tests.test_rsync_s.MyTests testMethod=test_rsync_s_i_vv_logfile_centos_7_7>

    def test_rsync_s_i_vv_logfile_centos_7_7(self):
        """
        Test 'rsync -ivv --logfile=xxx' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.rsync_s.parse(self.centos_7_7_rsync_i_vv_logfile.splitlines(), quiet=True)), self.centos_7_7_rsync_i_vv_logfile_streaming_json)
E       AssertionError: Lists differ: [{'ty[429 chars]1643344654}, {'type': 'file', 'filename': 'a.t[23885 chars]855}] != [{'ty[429 chars]1643373454}, {'type': 'file', 'filename': 'a.t[23885 chars]655}]
E
E       First differing element 0:
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643344654}
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643373454}
E
E       Diff is 31896 characters long. Set self.maxDiff to None to see it.

tests/test_rsync_s.py:148: AssertionError
________________ MyTests.test_rsync_s_i_vvv_logfile_centos_7_7 _________________

self = <tests.test_rsync_s.MyTests testMethod=test_rsync_s_i_vvv_logfile_centos_7_7>

    def test_rsync_s_i_vvv_logfile_centos_7_7(self):
        """
        Test 'rsync -ivvv --logfile=xxx' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.rsync_s.parse(self.centos_7_7_rsync_i_vvv_logfile.splitlines(), quiet=True)), self.centos_7_7_rsync_i_vvv_logfile_streaming_json)
E       AssertionError: Lists differ: [{'ty[429 chars]1643345427}, {'type': 'file', 'filename': 'a.t[36452 chars]187}] != [{'ty[429 chars]1643374227}, {'type': 'file', 'filename': 'a.t[36452 chars]987}]
E
E       First differing element 0:
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643345427}
E       {'typ[376 chars]se, 'extended_attribute_different': False, 'epoch': 1643374227}
E
E       Diff is 48356 characters long. Set self.maxDiff to None to see it.

tests/test_rsync_s.py:154: AssertionError
____________ MyTests.test_rsync_s_i_vvv_logfile_nochange_centos_7_7 ____________

self = <tests.test_rsync_s.MyTests testMethod=test_rsync_s_i_vvv_logfile_nochange_centos_7_7>

    def test_rsync_s_i_vvv_logfile_nochange_centos_7_7(self):
        """
        Test 'rsync -ivvv --logfile=xxx' on Centos 7.7 with no file changes
        """
>       self.assertEqual(list(jc.parsers.rsync_s.parse(self.centos_7_7_rsync_i_vvv_logfile_nochange.splitlines(), quiet=True)), self.centos_7_7_rsync_i_vvv_logfile_nochange_streaming_json)
E       AssertionError: Lists differ: [{'ty[430 chars]1643440289}, {'type': 'file', 'filename': 'a.t[24785 chars]293}] != [{'ty[430 chars]1643469089}, {'type': 'file', 'filename': 'a.t[24785 chars]093}]
E
E       First differing element 0:
E       {'typ[377 chars]se, 'extended_attribute_different': False, 'epoch': 1643440289}
E       {'typ[377 chars]se, 'extended_attribute_different': False, 'epoch': 1643469089}
E
E       Diff is 33071 characters long. Set self.maxDiff to None to see it.

tests/test_rsync_s.py:160: AssertionError
___________ MyTests.test_rsync_s_i_vvv_logfile_nochange_osx_10_14_6 ____________

self = <tests.test_rsync_s.MyTests testMethod=test_rsync_s_i_vvv_logfile_nochange_osx_10_14_6>

    def test_rsync_s_i_vvv_logfile_nochange_osx_10_14_6(self):
        """
        Test 'rsync -ivvv --logfile=xxx' on OSX 10.14.6 with no file changes
        """
>       self.assertEqual(list(jc.parsers.rsync_s.parse(self.osx_10_14_6_rsync_i_vvv_logfile_nochange.splitlines(), quiet=True)), self.osx_10_14_6_rsync_i_vvv_logfile_nochange_streaming_json)
E       AssertionError: Lists differ: [{'ty[363 chars]1643702966}, {'type': 'file', 'filename': 'a.t[11129 chars]037}] != [{'ty[363 chars]1643731766}, {'type': 'file', 'filename': 'a.t[11129 chars]837}]
E
E       First differing element 0:
E       {'typ[310 chars]fferent': False, 'group_different': False, 'epoch': 1643702966}
E       {'typ[310 chars]fferent': False, 'group_different': False, 'epoch': 1643731766}
E
E       Diff is 15546 characters long. Set self.maxDiff to None to see it.

tests/test_rsync_s.py:166: AssertionError
_________________________ MyTests.test_stat_centos_7_7 _________________________

self = <tests.test_stat.MyTests testMethod=test_stat_centos_7_7>

    def test_stat_centos_7_7(self):
        """
        Test 'stat /bin/*' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.stat.parse(self.centos_7_7_stat, quiet=True), self.centos_7_7_stat_json)
E       AssertionError: Lists differ: [{'fi[441 chars]1566257131, 'access_time_epoch_utc': None, 'mo[505592 chars]one}] != [{'fi[441 chars]1566282331, 'access_time_epoch_utc': None, 'mo[505592 chars]one}]
E
E       First differing element 0:
E       {'fil[440 chars]1566257131, 'access_time_epoch_utc': None, 'mo[175 chars]None}
E       {'fil[440 chars]1566282331, 'access_time_epoch_utc': None, 'mo[175 chars]None}
E
E       Diff is 820089 characters long. Set self.maxDiff to None to see it.

tests/test_stat.py:59: AssertionError
______________ MyTests.test_stat_filename_with_spaces_osx_10_14_6 ______________

self = <tests.test_stat.MyTests testMethod=test_stat_filename_with_spaces_osx_10_14_6>

    def test_stat_filename_with_spaces_osx_10_14_6(self):
        """
        Test 'stat' filename with spaces on OSX 10.14.6
        """
>       self.assertEqual(jc.parsers.stat.parse(self.osx_10_14_6_stat_filename_with_spaces, quiet=True), self.osx_10_14_6_stat_filename_with_spaces_json)
E       AssertionError: Lists differ: [{'fi[401 chars]1628867032, 'access_time_epoch_utc': None, 'mo[182 chars]one}] != [{'fi[401 chars]1628892232, 'access_time_epoch_utc': None, 'mo[182 chars]one}]
E
E       First differing element 0:
E       {'fil[400 chars]1628867032, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E       {'fil[400 chars]1628892232, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E
E       Diff is 1156 characters long. Set self.maxDiff to None to see it.

tests/test_stat.py:77: AssertionError
_________________________ MyTests.test_stat_freebsd12 __________________________

self = <tests.test_stat.MyTests testMethod=test_stat_freebsd12>

    def test_stat_freebsd12(self):
        """
        Test 'stat /foo/*' on FreeBSD12
        """
>       self.assertEqual(jc.parsers.stat.parse(self.freebsd12_stat, quiet=True), self.freebsd12_stat_json)
E       AssertionError: Lists differ: [{'fi[382 chars]1590558002, 'access_time_epoch_utc': None, 'mo[66580 chars]one}] != [{'fi[382 chars]1590583202, 'access_time_epoch_utc': None, 'mo[66580 chars]one}]
E
E       First differing element 0:
E       {'fil[381 chars]1590558002, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E       {'fil[381 chars]1590583202, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E
E       Diff is 125345 characters long. Set self.maxDiff to None to see it.

tests/test_stat.py:83: AssertionError
________________________ MyTests.test_stat_missing_data ________________________

self = <tests.test_stat.MyTests testMethod=test_stat_missing_data>

    def test_stat_missing_data(self):
        """
        Test 'stat /etc/passwd' with missing data.
        """
>       self.assertEqual(jc.parsers.stat.parse(self.ubuntu_20_4_stat_missing_data, quiet=True), self.ubuntu_20_4_stat_missing_data_json)
E       AssertionError: Lists differ: [{'fi[418 chars]1685625172, 'access_time_epoch_utc': None, 'mo[120 chars]one}] != [{'fi[418 chars]1685650372, 'access_time_epoch_utc': None, 'mo[120 chars]one}]
E
E       First differing element 0:
E       {'fil[417 chars]1685625172, 'access_time_epoch_utc': None, 'mo[119 chars]None}
E       {'fil[417 chars]1685650372, 'access_time_epoch_utc': None, 'mo[119 chars]None}
E
E       Diff is 1006 characters long. Set self.maxDiff to None to see it.

tests/test_stat.py:89: AssertionError
________________________ MyTests.test_stat_osx_10_14_6 _________________________

self = <tests.test_stat.MyTests testMethod=test_stat_osx_10_14_6>

    def test_stat_osx_10_14_6(self):
        """
        Test 'stat /foo/*' on OSX 10.14.6
        """
>       self.assertEqual(jc.parsers.stat.parse(self.osx_10_14_6_stat, quiet=True), self.osx_10_14_6_stat_json)
E       AssertionError: Lists differ: [{'fi[391 chars]1590164102, 'access_time_epoch_utc': None, 'mo[58580 chars]one}] != [{'fi[391 chars]1590189302, 'access_time_epoch_utc': None, 'mo[58580 chars]one}]
E
E       First differing element 0:
E       {'fil[390 chars]1590164102, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E       {'fil[390 chars]1590189302, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E
E       Diff is 107758 characters long. Set self.maxDiff to None to see it.

tests/test_stat.py:71: AssertionError
________________________ MyTests.test_stat_ubuntu_18_4 _________________________

self = <tests.test_stat.MyTests testMethod=test_stat_ubuntu_18_4>

    def test_stat_ubuntu_18_4(self):
        """
        Test 'stat /bin/*' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.stat.parse(self.ubuntu_18_4_stat, quiet=True), self.ubuntu_18_4_stat_json)
E       AssertionError: Lists differ: [{'fi[444 chars]1573719483, 'access_time_epoch_utc': 157371948[117866 chars]one}] != [{'fi[444 chars]1573748283, 'access_time_epoch_utc': 157371948[117866 chars]one}]
E
E       First differing element 0:
E       {'fil[443 chars]1573719483, 'access_time_epoch_utc': 157371948[193 chars]None}
E       {'fil[443 chars]1573748283, 'access_time_epoch_utc': 157371948[193 chars]None}
E
E       Diff is 190436 characters long. Set self.maxDiff to None to see it.

tests/test_stat.py:65: AssertionError
________________________ MyTests.test_stat_s_centos_7_7 ________________________

self = <tests.test_stat_s.MyTests testMethod=test_stat_s_centos_7_7>

    def test_stat_s_centos_7_7(self):
        """
        Test 'stat /bin/*' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.stat_s.parse(self.centos_7_7_stat.splitlines(), quiet=True)), self.centos_7_7_stat_streaming_json)
E       AssertionError: Lists differ: [{'fi[441 chars]1566257131, 'access_time_epoch_utc': None, 'mo[505592 chars]one}] != [{'fi[441 chars]1566282331, 'access_time_epoch_utc': None, 'mo[505592 chars]one}]
E
E       First differing element 0:
E       {'fil[440 chars]1566257131, 'access_time_epoch_utc': None, 'mo[175 chars]None}
E       {'fil[440 chars]1566282331, 'access_time_epoch_utc': None, 'mo[175 chars]None}
E
E       Diff is 820089 characters long. Set self.maxDiff to None to see it.

tests/test_stat_s.py:65: AssertionError
_____________ MyTests.test_stat_s_filename_with_spaces_osx_10_14_6 _____________

self = <tests.test_stat_s.MyTests testMethod=test_stat_s_filename_with_spaces_osx_10_14_6>

    def test_stat_s_filename_with_spaces_osx_10_14_6(self):
        """
        Test 'stat' filename with spaces on OSX 10.14.6
        """
>       self.assertEqual(list(jc.parsers.stat_s.parse(self.osx_10_14_6_stat_filename_with_spaces.splitlines(), quiet=True)), self.osx_10_14_6_stat_filename_with_spaces_streaming_json)
E       AssertionError: Lists differ: [{'fi[401 chars]1628867032, 'access_time_epoch_utc': None, 'mo[182 chars]one}] != [{'fi[401 chars]1628892232, 'access_time_epoch_utc': None, 'mo[182 chars]one}]
E
E       First differing element 0:
E       {'fil[400 chars]1628867032, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E       {'fil[400 chars]1628892232, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E
E       Diff is 1156 characters long. Set self.maxDiff to None to see it.

tests/test_stat_s.py:83: AssertionError
________________________ MyTests.test_stat_s_freebsd12 _________________________

self = <tests.test_stat_s.MyTests testMethod=test_stat_s_freebsd12>

    def test_stat_s_freebsd12(self):
        """
        Test 'stat /foo/*' on FreeBSD12
        """
>       self.assertEqual(list(jc.parsers.stat_s.parse(self.freebsd12_stat.splitlines(), quiet=True)), self.freebsd12_stat_streaming_json)
E       AssertionError: Lists differ: [{'fi[382 chars]1590558002, 'access_time_epoch_utc': None, 'mo[66580 chars]one}] != [{'fi[382 chars]1590583202, 'access_time_epoch_utc': None, 'mo[66580 chars]one}]
E
E       First differing element 0:
E       {'fil[381 chars]1590558002, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E       {'fil[381 chars]1590583202, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E
E       Diff is 125345 characters long. Set self.maxDiff to None to see it.

tests/test_stat_s.py:89: AssertionError
_______________________ MyTests.test_stat_s_osx_10_14_6 ________________________

self = <tests.test_stat_s.MyTests testMethod=test_stat_s_osx_10_14_6>

    def test_stat_s_osx_10_14_6(self):
        """
        Test 'stat /bin/*' on OSX 10.14.6
        """
>       self.assertEqual(list(jc.parsers.stat_s.parse(self.osx_10_14_6_stat.splitlines(), quiet=True)), self.osx_10_14_6_stat_streaming_json)
E       AssertionError: Lists differ: [{'fi[391 chars]1590164102, 'access_time_epoch_utc': None, 'mo[58580 chars]one}] != [{'fi[391 chars]1590189302, 'access_time_epoch_utc': None, 'mo[58580 chars]one}]
E
E       First differing element 0:
E       {'fil[390 chars]1590164102, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E       {'fil[390 chars]1590189302, 'access_time_epoch_utc': None, 'mo[181 chars]None}
E
E       Diff is 107758 characters long. Set self.maxDiff to None to see it.

tests/test_stat_s.py:77: AssertionError
_______________________ MyTests.test_stat_s_ubuntu_18_4 ________________________

self = <tests.test_stat_s.MyTests testMethod=test_stat_s_ubuntu_18_4>

    def test_stat_s_ubuntu_18_4(self):
        """
        Test 'stat /bin/*' on Ubuntu 18.4
        """
>       self.assertEqual(list(jc.parsers.stat_s.parse(self.ubuntu_18_4_stat.splitlines(), quiet=True)), self.ubuntu_18_4_stat_streaming_json)
E       AssertionError: Lists differ: [{'fi[444 chars]1573719483, 'access_time_epoch_utc': 157371948[117866 chars]one}] != [{'fi[444 chars]1573748283, 'access_time_epoch_utc': 157371948[117866 chars]one}]
E
E       First differing element 0:
E       {'fil[443 chars]1573719483, 'access_time_epoch_utc': 157371948[193 chars]None}
E       {'fil[443 chars]1573748283, 'access_time_epoch_utc': 157371948[193 chars]None}
E
E       Diff is 190436 characters long. Set self.maxDiff to None to see it.

tests/test_stat_s.py:71: AssertionError
__________________________ MyTests.test_syslog_sample __________________________

self = <tests.test_syslog.MyTests testMethod=test_syslog_sample>

    def test_syslog_sample(self):
        """
        Test 'syslog' with sample data
        """
>       self.assertEqual(jc.parsers.syslog.parse(self.syslog, quiet=True), self.syslog_json)
E       AssertionError: Lists differ: [{'pr[248 chars]1061702055, 'timestamp_epoch_utc': None}, {'un[2319 chars]sd'}] != [{'pr[248 chars]1061727255, 'timestamp_epoch_utc': None}, {'un[2319 chars]sd'}]
E
E       First differing element 0:
E       {'pri[224 chars].", 'timestamp_epoch': 1061702055, 'timestamp_epoch_utc': None}
E       {'pri[224 chars].", 'timestamp_epoch': 1061727255, 'timestamp_epoch_utc': None}
E
E       Diff is 3871 characters long. Set self.maxDiff to None to see it.

tests/test_syslog.py:30: AssertionError
____________________________ MyTests.test_syslog_s _____________________________

self = <tests.test_syslog_s.MyTests testMethod=test_syslog_s>

    def test_syslog_s(self):
        """
        Test syslog file
        """
>       self.assertEqual(list(jc.parsers.syslog_s.parse(self.syslog.splitlines(), quiet=True)), self.syslog_streaming_json)
E       AssertionError: Lists differ: [{'pr[248 chars]1061702055, 'timestamp_epoch_utc': None}, {'un[2319 chars]sd'}] != [{'pr[248 chars]1061727255, 'timestamp_epoch_utc': None}, {'un[2319 chars]sd'}]
E
E       First differing element 0:
E       {'pri[224 chars].", 'timestamp_epoch': 1061702055, 'timestamp_epoch_utc': None}
E       {'pri[224 chars].", 'timestamp_epoch': 1061727255, 'timestamp_epoch_utc': None}
E
E       Diff is 3871 characters long. Set self.maxDiff to None to see it.

tests/test_syslog_s.py:33: AssertionError
_______________________ MyTests.test_windows_systeminfo ________________________

self = <tests.test_systeminfo.MyTests testMethod=test_windows_systeminfo>

    def test_windows_systeminfo(self):
        """
        Test a sample Windows "systeminfo" command output
        """
        for tf in MyTests.test_files:
            in_var = getattr(self, self.varName(tf))
            out_var = getattr(self, self.varName(tf) + "_json")

>           self.assertEqual(jc.parsers.systeminfo.parse(in_var, quiet=True), out_var)
E           AssertionError: {'hos[5440 chars]}], 'system_boot_time_epoch': 1616418951, 'sys[110 chars]None} != {'hos[5440 chars]}], 'original_install_date_epoch': 1420142400,[110 chars]None}
E           Diff is 10260 characters long. Set self.maxDiff to None to see it.

tests/test_systeminfo.py:43: AssertionError
_______________________ MyTests.test_10_digit_timestamp ________________________

self = <tests.test_timestamp.MyTests testMethod=test_10_digit_timestamp>

    def test_10_digit_timestamp(self):
        """
        Test 10 digit timestamp string
        """
        data = r'1658599410'
        expected = json.loads(r"""{"naive":{"year":2022,"month":"Jul","month_num":7,"day":23,"weekday":"Sat","weekday_num":6,"hour":11,"hour_24":11,"minute":3,"second":30,"period":"AM","day_of_year":204,"week_of_year":29,"iso":"2022-07-23T11:03:30"},"utc":{"year":2022,"month":"Jul","month_num":7,"day":23,"weekday":"Sat","weekday_num":6,"hour":6,"hour_24":18,"minute":3,"second":30,"period":"PM","utc_offset":"+0000","day_of_year":204,"week_of_year":29,"iso":"2022-07-23T18:03:30+00:00"}}""")
>       self.assertEqual(jc.parsers.timestamp.parse(data, quiet=True), expected)
E       AssertionError: {'nai[102 chars]ur': 6, 'hour_24': 18, 'minute': 3, 'second': [355 chars]00'}} != {'nai[102 chars]ur': 11, 'hour_24': 11, 'minute': 3, 'second':[356 chars]00'}}
E       Diff is 1198 characters long. Set self.maxDiff to None to see it.

tests/test_timestamp.py:20: AssertionError
_______________________ MyTests.test_13_digit_timestamp ________________________

self = <tests.test_timestamp.MyTests testMethod=test_13_digit_timestamp>

    def test_13_digit_timestamp(self):
        """
        Test 13 digit timestamp string (with milliseconds)
        """
        data = r'1658604427154'
        expected = json.loads(r"""{"naive":{"year":2022,"month":"Jul","month_num":7,"day":23,"weekday":"Sat","weekday_num":6,"hour":12,"hour_24":12,"minute":27,"second":7,"period":"PM","day_of_year":204,"week_of_year":29,"iso":"2022-07-23T12:27:07"},"utc":{"year":2022,"month":"Jul","month_num":7,"day":23,"weekday":"Sat","weekday_num":6,"hour":7,"hour_24":19,"minute":27,"second":7,"period":"PM","utc_offset":"+0000","day_of_year":204,"week_of_year":29,"iso":"2022-07-23T19:27:07+00:00"}}""")
>       self.assertEqual(jc.parsers.timestamp.parse(data, quiet=True), expected)
E       AssertionError: {'nai[102 chars]ur': 7, 'hour_24': 19, 'minute': 27, 'second':[355 chars]00'}} != {'nai[102 chars]ur': 12, 'hour_24': 12, 'minute': 27, 'second'[356 chars]00'}}
E       Diff is 1115 characters long. Set self.maxDiff to None to see it.

tests/test_timestamp.py:28: AssertionError
____________________________ MyTests.test_tune2fs_l ____________________________

self = <tests.test_tune2fs.MyTests testMethod=test_tune2fs_l>

    def test_tune2fs_l(self):
        """
        Test 'tune2fs -l'
        """
>       self.assertEqual(
            parse(self.f_in['tune2fs'], quiet=True),
            self.f_json['tune2fs']
        )
E       AssertionError: {'ver[1740 chars] 1586185837, 'filesystem_created_epoch_utc': N[209 chars]None} != {'ver[1740 chars] 1586211037, 'filesystem_created_epoch_utc': N[209 chars]None}
E       Diff is 3010 characters long. Set self.maxDiff to None to see it.

tests/test_tune2fs.py:40: AssertionError
__________________ MyTests.test_upower_d_clocale_ubuntu_18_4 ___________________

self = <tests.test_upower.MyTests testMethod=test_upower_d_clocale_ubuntu_18_4>

    def test_upower_d_clocale_ubuntu_18_4(self):
        """
        Test 'upower -d' on Ubuntu 18.4 using LANG=C
        """
>       self.assertEqual(jc.parsers.upower.parse(self.ubuntu_18_4_upower_d, quiet=True), self.ubuntu_18_4_upower_d_json)
E       AssertionError: Lists differ: [{'ty[375 chars] 1615487288, 'updated_epoch_utc': 1615487288},[535 chars]ep'}] != [{'ty[375 chars] 1615516088, 'updated_epoch_utc': 1615487288},[535 chars]ep'}]
E
E       First differing element 0:
E       {'typ[356 chars], 'updated_epoch': 1615487288, 'updated_epoch_utc': 1615487288}
E       {'typ[356 chars], 'updated_epoch': 1615516088, 'updated_epoch_utc': 1615487288}
E
E       Diff is 1336 characters long. Set self.maxDiff to None to see it.

tests/test_upower.py:72: AssertionError
______________________ MyTests.test_upower_d_ubuntu_18_4 _______________________

self = <tests.test_upower.MyTests testMethod=test_upower_d_ubuntu_18_4>

    def test_upower_d_ubuntu_18_4(self):
        """
        Test 'upower -d' on Ubuntu 18.4 using LANG=en_US.UTF-8
        """
>       self.assertEqual(jc.parsers.upower.parse(self.ubuntu_18_4_upower_d, quiet=True), self.ubuntu_18_4_upower_d_json)
E       AssertionError: Lists differ: [{'ty[375 chars] 1615487288, 'updated_epoch_utc': 1615487288},[535 chars]ep'}] != [{'ty[375 chars] 1615516088, 'updated_epoch_utc': 1615487288},[535 chars]ep'}]
E
E       First differing element 0:
E       {'typ[356 chars], 'updated_epoch': 1615487288, 'updated_epoch_utc': 1615487288}
E       {'typ[356 chars], 'updated_epoch': 1615516088, 'updated_epoch_utc': 1615487288}
E
E       Diff is 1336 characters long. Set self.maxDiff to None to see it.

tests/test_upower.py:66: AssertionError
________________________ MyTests.test_upower_i_c_locale ________________________

self = <tests.test_upower.MyTests testMethod=test_upower_i_c_locale>

    def test_upower_i_c_locale(self):
        """
        Test 'upower -i' with LANG=C time output
        """
>       self.assertEqual(jc.parsers.upower.parse(self.generic_upower_i_c_locale, quiet=True), self.generic_upower_i_c_locale_json)
E       AssertionError: Lists differ: [{'na[1300 chars]o': 1, 'updated_epoch': 1328812935, 'updated_epoch_utc': None}] != [{'na[1300 chars]o': 1, 'updated_epoch': 1328841735, 'updated_epoch_utc': None}]
E
E       First differing element 0:
E       {'nat[1298 chars]go': 1, 'updated_epoch': 1328812935, 'updated_epoch_utc': None}
E       {'nat[1298 chars]go': 1, 'updated_epoch': 1328841735, 'updated_epoch_utc': None}
E
E       Diff is 2253 characters long. Set self.maxDiff to None to see it.

tests/test_upower.py:90: AssertionError
____________________ MyTests.test_upower_i_non_utc_generic _____________________

self = <tests.test_upower.MyTests testMethod=test_upower_i_non_utc_generic>

    def test_upower_i_non_utc_generic(self):
        """
        Test 'upower -i' with non-utc time output
        """
>       self.assertEqual(jc.parsers.upower.parse(self.generic_upower_i_non_utc, quiet=True), self.generic_upower_i_non_utc_json)
E       AssertionError: Lists differ: [{'na[754 chars]: 101, 'updated_epoch': 1569934241, 'updated_epoch_utc': None}] != [{'na[754 chars]: 101, 'updated_epoch': 1569959441, 'updated_epoch_utc': None}]
E
E       First differing element 0:
E       {'nat[752 chars]': 101, 'updated_epoch': 1569934241, 'updated_epoch_utc': None}
E       {'nat[752 chars]': 101, 'updated_epoch': 1569959441, 'updated_epoch_utc': None}
E
E       Diff is 1263 characters long. Set self.maxDiff to None to see it.

tests/test_upower.py:84: AssertionError
______________________ MyTests.test_upower_i_ubuntu_18_4 _______________________

self = <tests.test_upower.MyTests testMethod=test_upower_i_ubuntu_18_4>

    def test_upower_i_ubuntu_18_4(self):
        """
        Test 'upower -i' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.upower.parse(self.ubuntu_18_4_upower_i, quiet=True), self.ubuntu_18_4_upower_i_json)
E       AssertionError: Lists differ: [{'na[274 chars] 'updated_epoch': 1615487288, 'updated_epoch_utc': 1615487288}] != [{'na[274 chars] 'updated_epoch': 1615516088, 'updated_epoch_utc': 1615487288}]
E
E       First differing element 0:
E       {'nat[272 chars], 'updated_epoch': 1615487288, 'updated_epoch_utc': 1615487288}
E       {'nat[272 chars], 'updated_epoch': 1615516088, 'updated_epoch_utc': 1615487288}
E
E         [{'detail': {'icon_name': 'ac-adapter-symbolic',
E                      'online': True,
E                      'type': 'line-power',
E                      'warning_level': None},
E           'has_history': False,
E           'has_statistics': False,
E           'native_path': 'ACAD',
E           'power_supply': True,
E           'updated': 'Thu 11 Mar 2021 06:28:08 PM UTC',
E       -   'updated_epoch': 1615487288,
E       ?                        ^^^^
E
E       +   'updated_epoch': 1615516088,
E       ?                        ^^^^
E
E           'updated_epoch_utc': 1615487288,
E           'updated_seconds_ago': 442049}]

tests/test_upower.py:60: AssertionError
______________________ MyTests.test_upower_i_utc_generic _______________________

self = <tests.test_upower.MyTests testMethod=test_upower_i_utc_generic>

    def test_upower_i_utc_generic(self):
        """
        Test 'upower -i' with utc time output
        """
>       self.assertEqual(jc.parsers.upower.parse(self.generic_upower_i_utc, quiet=True), self.generic_upower_i_utc_json)
E       AssertionError: Lists differ: [{'na[760 chars] 'updated_epoch': 1569934241, 'updated_epoch_utc': 1569934241}] != [{'na[760 chars] 'updated_epoch': 1569959441, 'updated_epoch_utc': 1569934241}]
E
E       First differing element 0:
E       {'nat[758 chars], 'updated_epoch': 1569934241, 'updated_epoch_utc': 1569934241}
E       {'nat[758 chars], 'updated_epoch': 1569959441, 'updated_epoch_utc': 1569934241}
E
E       Diff is 1269 characters long. Set self.maxDiff to None to see it.

tests/test_upower.py:78: AssertionError
_________________________ MyTests.test_vmstat_at_5_10 __________________________

self = <tests.test_vmstat.MyTests testMethod=test_vmstat_at_5_10>

    def test_vmstat_at_5_10(self):
        """
        Test 'vmstat -at 5 10'
        """
>       self.assertEqual(jc.parsers.vmstat.parse(self.centos_7_7_vmstat_at_5_10, quiet=True), self.centos_7_7_vmstat_at_5_10_json)
E       AssertionError: Lists differ: [{'ru[440 chars]1631824393, 'epoch_utc': None}, {'runnable_pro[1411 chars]one}] != [{'ru[440 chars]1631849593, 'epoch_utc': None}, {'runnable_pro[1411 chars]one}]
E
E       First differing element 0:
E       {'run[406 chars]13', 'timezone': 'PDT', 'epoch': 1631824393, 'epoch_utc': None}
E       {'run[406 chars]13', 'timezone': 'PDT', 'epoch': 1631849593, 'epoch_utc': None}
E
E       Diff is 2555 characters long. Set self.maxDiff to None to see it.

tests/test_vmstat.py:90: AssertionError
___________________________ MyTests.test_vmstat_awt ____________________________

self = <tests.test_vmstat.MyTests testMethod=test_vmstat_awt>

    def test_vmstat_awt(self):
        """
        Test 'vmstat -awt'
        """
>       self.assertEqual(jc.parsers.vmstat.parse(self.centos_7_7_vmstat_awt, quiet=True), self.centos_7_7_vmstat_awt_json)
E       AssertionError: Lists differ: [{'ru[408 chars]0', 'timezone': 'PDT', 'epoch': 1631824290, 'epoch_utc': None}] != [{'ru[408 chars]0', 'timezone': 'PDT', 'epoch': 1631849490, 'epoch_utc': None}]
E
E       First differing element 0:
E       {'run[406 chars]30', 'timezone': 'PDT', 'epoch': 1631824290, 'epoch_utc': None}
E       {'run[406 chars]30', 'timezone': 'PDT', 'epoch': 1631849490, 'epoch_utc': None}
E
E         [{'active_mem': 312724,
E           'blocks_in': 1,
E           'blocks_out': 3,
E           'buffer_mem': None,
E           'cache_mem': None,
E           'context_switches': 57,
E       -   'epoch': 1631824290,
E       ?                 - ^
E
E       +   'epoch': 1631849490,
E       ?                  ^^
E
E           'epoch_utc': None,
E           'free_mem': 2794864,
E           'idle_time': 99,
E           'inactive_mem': 295968,
E           'interrupts': 29,
E           'io_wait_time': 0,
E           'runnable_procs': 2,
E           'stolen_time': 0,
E           'swap_in': 0,
E           'swap_out': 0,
E           'system_time': 0,
E           'timestamp': '2021-09-16 20:31:30',
E           'timezone': 'PDT',
E           'uninterruptible_sleeping_procs': 0,
E           'user_time': 0,
E           'virtual_mem_used': 0}]

tests/test_vmstat.py:96: AssertionError
____________________________ MyTests.test_vmstat_dt ____________________________

self = <tests.test_vmstat.MyTests testMethod=test_vmstat_dt>

    def test_vmstat_dt(self):
        """
        Test 'vmstat -dt'
        """
>       self.assertEqual(jc.parsers.vmstat.parse(self.centos_7_7_vmstat_dt, quiet=True), self.centos_7_7_vmstat_dt_json)
E       AssertionError: Lists differ: [{'di[294 chars]1631824348, 'epoch_utc': 1631824348}, {'disk':[930 chars]348}] != [{'di[294 chars]1631849548, 'epoch_utc': 1631824348}, {'disk':[930 chars]348}]
E
E       First differing element 0:
E       {'dis[266 chars]timezone': 'UTC', 'epoch': 1631824348, 'epoch_utc': 1631824348}
E       {'dis[266 chars]timezone': 'UTC', 'epoch': 1631849548, 'epoch_utc': 1631824348}
E
E       Diff is 1800 characters long. Set self.maxDiff to None to see it.

tests/test_vmstat.py:108: AssertionError
___________________ MyTests.test_vmstat_s_at_5_10_centos_7_7 ___________________

self = <tests.test_vmstat_s.MyTests testMethod=test_vmstat_s_at_5_10_centos_7_7>

    def test_vmstat_s_at_5_10_centos_7_7(self):
        """
        Test 'vmstat -at 5 10' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.vmstat_s.parse(self.centos_7_7_vmstat_at_5_10.splitlines(), quiet=True)), self.centos_7_7_vmstat_at_5_10_streaming_json)
E       AssertionError: Lists differ: [{'ru[440 chars]1631824393, 'epoch_utc': None}, {'runnable_pro[1411 chars]one}] != [{'ru[440 chars]1631849593, 'epoch_utc': None}, {'runnable_pro[1411 chars]one}]
E
E       First differing element 0:
E       {'run[406 chars]13', 'timezone': 'PDT', 'epoch': 1631824393, 'epoch_utc': None}
E       {'run[406 chars]13', 'timezone': 'PDT', 'epoch': 1631849593, 'epoch_utc': None}
E
E       Diff is 2555 characters long. Set self.maxDiff to None to see it.

tests/test_vmstat_s.py:107: AssertionError
_____________________ MyTests.test_vmstat_s_awt_centos_7_7 _____________________

self = <tests.test_vmstat_s.MyTests testMethod=test_vmstat_s_awt_centos_7_7>

    def test_vmstat_s_awt_centos_7_7(self):
        """
        Test 'vmstat -awt' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.vmstat_s.parse(self.centos_7_7_vmstat_awt.splitlines(), quiet=True)), self.centos_7_7_vmstat_awt_streaming_json)
E       AssertionError: Lists differ: [{'ru[408 chars]0', 'timezone': 'PDT', 'epoch': 1631824290, 'epoch_utc': None}] != [{'ru[408 chars]0', 'timezone': 'PDT', 'epoch': 1631849490, 'epoch_utc': None}]
E
E       First differing element 0:
E       {'run[406 chars]30', 'timezone': 'PDT', 'epoch': 1631824290, 'epoch_utc': None}
E       {'run[406 chars]30', 'timezone': 'PDT', 'epoch': 1631849490, 'epoch_utc': None}
E
E         [{'active_mem': 312724,
E           'blocks_in': 1,
E           'blocks_out': 3,
E           'buffer_mem': None,
E           'cache_mem': None,
E           'context_switches': 57,
E       -   'epoch': 1631824290,
E       ?                 - ^
E
E       +   'epoch': 1631849490,
E       ?                  ^^
E
E           'epoch_utc': None,
E           'free_mem': 2794864,
E           'idle_time': 99,
E           'inactive_mem': 295968,
E           'interrupts': 29,
E           'io_wait_time': 0,
E           'runnable_procs': 2,
E           'stolen_time': 0,
E           'swap_in': 0,
E           'swap_out': 0,
E           'system_time': 0,
E           'timestamp': '2021-09-16 20:31:30',
E           'timezone': 'PDT',
E           'uninterruptible_sleeping_procs': 0,
E           'user_time': 0,
E           'virtual_mem_used': 0}]

tests/test_vmstat_s.py:113: AssertionError
_____________________ MyTests.test_vmstat_s_dt_centos_7_7 ______________________

self = <tests.test_vmstat_s.MyTests testMethod=test_vmstat_s_dt_centos_7_7>

    def test_vmstat_s_dt_centos_7_7(self):
        """
        Test 'vmstat -dt' on Centos 7.7
        """
>       self.assertEqual(list(jc.parsers.vmstat_s.parse(self.centos_7_7_vmstat_dt.splitlines(), quiet=True)), self.centos_7_7_vmstat_dt_streaming_json)
E       AssertionError: Lists differ: [{'di[294 chars]1631824348, 'epoch_utc': 1631824348}, {'disk':[930 chars]348}] != [{'di[294 chars]1631849548, 'epoch_utc': 1631824348}, {'disk':[930 chars]348}]
E
E       First differing element 0:
E       {'dis[266 chars]timezone': 'UTC', 'epoch': 1631824348, 'epoch_utc': 1631824348}
E       {'dis[266 chars]timezone': 'UTC', 'epoch': 1631849548, 'epoch_utc': 1631824348}
E
E       Diff is 1800 characters long. Set self.maxDiff to None to see it.

tests/test_vmstat_s.py:125: AssertionError
________________________ MyTests.test_who_a_centos_7_7 _________________________

self = <tests.test_who.MyTests testMethod=test_who_a_centos_7_7>

    def test_who_a_centos_7_7(self):
        """
        Test 'who -a' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.who.parse(self.centos_7_7_who_a, quiet=True), self.centos_7_7_who_a_json)
E       AssertionError: Lists differ: [{'ev[51 chars]: 1582978380}, {'event': 'login', 'tty': 'tty1[567 chars]880}] != [{'ev[51 chars]: 1583007180}, {'event': 'login', 'tty': 'tty1[567 chars]680}]
E
E       First differing element 0:
E       {'event': 'reboot', 'time': '2020-02-29 12:13', 'epoch': 1582978380}
E       {'event': 'reboot', 'time': '2020-02-29 12:13', 'epoch': 1583007180}
E
E       Diff is 1306 characters long. Set self.maxDiff to None to see it.

tests/test_who.py:84: AssertionError
________________________ MyTests.test_who_a_ubuntu_18_4 ________________________

self = <tests.test_who.MyTests testMethod=test_who_a_ubuntu_18_4>

    def test_who_a_ubuntu_18_4(self):
        """
        Test 'who -a' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.who.parse(self.ubuntu_18_4_who_a, quiet=True), self.ubuntu_18_4_who_a_json)
E       AssertionError: Lists differ: [{'ev[53 chars]1583117520}, {'user': 'kbrazil', 'writeable_tt[447 chars]640}] != [{'ev[53 chars]1583146320}, {'user': 'kbrazil', 'writeable_tt[447 chars]440}]
E
E       First differing element 0:
E       {'event': 'reboot', 'time': '2020-03-02 02:52', 'epoch': 1583117520}
E       {'event': 'reboot', 'time': '2020-03-02 02:52', 'epoch': 1583146320}
E
E       Diff is 1098 characters long. Set self.maxDiff to None to see it.

tests/test_who.py:90: AssertionError
_________________________ MyTests.test_who_centos_7_7 __________________________

self = <tests.test_who.MyTests testMethod=test_who_centos_7_7>

    def test_who_centos_7_7(self):
        """
        Test 'who' on Centos 7.7
        """
>       self.assertEqual(jc.parsers.who.parse(self.centos_7_7_who, quiet=True), self.centos_7_7_who_json)
E       AssertionError: Lists differ: [{'us[67 chars]: 1582978440}, {'user': 'kbrazil', 'tty': 'pts[73 chars]780}] != [{'us[67 chars]: 1583007240}, {'user': 'kbrazil', 'tty': 'pts[73 chars]580}]
E
E       First differing element 0:
E       {'use[16 chars]tty': 'ttyS0', 'time': '2020-02-29 12:14', 'epoch': 1582978440}
E       {'use[16 chars]tty': 'ttyS0', 'time': '2020-02-29 12:14', 'epoch': 1583007240}
E
E       - [{'epoch': 1582978440,
E       ?                ----
E
E       + [{'epoch': 1583007240,
E       ?               ++++
E
E           'time': '2020-02-29 12:14',
E           'tty': 'ttyS0',
E           'user': 'kbrazil'},
E       -  {'epoch': 1583001780,
E       ?                  ^^
E
E       +  {'epoch': 1583030580,
E       ?                 + ^
E
E           'from': '192.168.71.1',
E           'time': '2020-02-29 18:43',
E           'tty': 'pts/0',
E           'user': 'kbrazil'}]

tests/test_who.py:66: AssertionError
________________________ MyTests.test_who_login_screen _________________________

self = <tests.test_who.MyTests testMethod=test_who_login_screen>

    def test_who_login_screen(self):
        """
        Test 'who' with (login screen) as remote
        """
>       self.assertEqual(jc.parsers.who.parse(self.generic_who_login_screen, quiet=True), self.generic_who_login_screen_json)
E       AssertionError: Lists differ: [{'us[91 chars]1697918760}, {'user': 'atemu', 'tty': ':0', 't[140 chars]620}] != [{'us[91 chars]1697943960}, {'user': 'atemu', 'tty': ':0', 't[140 chars]820}]
E
E       First differing element 0:
E       {'use[38 chars]2023-10-21 20:06', 'from': 'login screen', 'epoch': 1697918760}
E       {'use[38 chars]2023-10-21 20:06', 'from': 'login screen', 'epoch': 1697943960}
E
E       - [{'epoch': 1697918760,
E       ?                 ^^^
E
E       + [{'epoch': 1697943960,
E       ?                 ^^^
E
E           'from': 'login screen',
E           'time': '2023-10-21 20:06',
E           'tty': 'seat0',
E           'user': 'atemu'},
E       -  {'epoch': 1697918760,
E       ?                 ^^^
E
E       +  {'epoch': 1697943960,
E       ?                 ^^^
E
E           'from': ':0',
E           'time': '2023-10-21 20:06',
E           'tty': ':0',
E           'user': 'atemu'},
E       -  {'epoch': 1698085620,
E       ?                  --
E
E       +  {'epoch': 1698110820,
E       ?                ++
E
E           'time': '2023-10-23 18:27',
E           'tty': 'pts/8',
E           'user': 'atemu'}]

tests/test_who.py:102: AssertionError
_________________________ MyTests.test_who_ubuntu_18_4 _________________________

self = <tests.test_who.MyTests testMethod=test_who_ubuntu_18_4>

    def test_who_ubuntu_18_4(self):
        """
        Test 'who' on Ubuntu 18.4
        """
>       self.assertEqual(jc.parsers.who.parse(self.ubuntu_18_4_who, quiet=True), self.ubuntu_18_4_who_json)
E       AssertionError: Lists differ: [{'us[69 chars]1583117520}, {'user': 'kbrazil', 'tty': 'pts/0[71 chars]640}] != [{'us[69 chars]1583146320}, {'user': 'kbrazil', 'tty': 'pts/0[71 chars]440}]
E
E       First differing element 0:
E       {'use[16 chars]tty': 'ttyS0', 'time': '2020-03-02 02:52', 'epoch': 1583117520}
E       {'use[16 chars]tty': 'ttyS0', 'time': '2020-03-02 02:52', 'epoch': 1583146320}
E
E       - [{'epoch': 1583117520,
E       ?                 ^^^
E
E       + [{'epoch': 1583146320,
E       ?                 ^^^
E
E           'time': '2020-03-02 02:52',
E           'tty': 'ttyS0',
E           'user': 'kbrazil'},
E       -  {'epoch': 1583117640,
E       ?                 ^^
E
E       +  {'epoch': 1583146440,
E       ?                 ^ +
E
E           'from': '192.168.71.1',
E           'time': '2020-03-02 02:54',
E           'tty': 'pts/0',
E           'user': 'kbrazil'}]

tests/test_who.py:72: AssertionError
=========================== short test summary info ============================
SKIPPED [1] tests/test_jc_cli.py:241: pygments library installed
FAILED tests/test_cbt.py::MyTests::test_cbt_multiple_rows_raw - AssertionErro...
FAILED tests/test_cef.py::MyTests::test_cef_sample - AssertionError: Lists di...
FAILED tests/test_cef_s.py::MyTests::test_cef_s_sample - AssertionError: List...
FAILED tests/test_certbot.py::MyTests::test_certbot_certificates - AssertionE...
FAILED tests/test_clf.py::MyTests::test_clf - AssertionError: Lists differ: [...
FAILED tests/test_clf_s.py::MyTests::test_clf_s_centos_7_7 - AssertionError: ...
FAILED tests/test_date.py::MyTests::test_date - AssertionError: {'yea[267 cha...
FAILED tests/test_date.py::MyTests::test_date_after_midnight - AssertionError...
FAILED tests/test_date.py::MyTests::test_date_am_ubuntu_20_04 - AssertionErro...
FAILED tests/test_date.py::MyTests::test_date_before_midnight - AssertionErro...
FAILED tests/test_date.py::MyTests::test_date_pm_ubuntu_20_04 - AssertionErro...
FAILED tests/test_dig.py::MyTests::test_dig_aaaa_centos_7_7 - AssertionError:...
FAILED tests/test_dig.py::MyTests::test_dig_aaaa_osx_10_11_6 - AssertionError...
FAILED tests/test_dig.py::MyTests::test_dig_aaaa_osx_10_14_6 - AssertionError...
FAILED tests/test_dig.py::MyTests::test_dig_aaaa_ubuntu_18_4 - AssertionError...
FAILED tests/test_dig.py::MyTests::test_dig_additional - AssertionError: List...
FAILED tests/test_dig.py::MyTests::test_dig_additional2 - AssertionError: Lis...
FAILED tests/test_dig.py::MyTests::test_dig_additional3 - AssertionError: Lis...
FAILED tests/test_dig.py::MyTests::test_dig_answer_spaces - AssertionError: L...
FAILED tests/test_dig.py::MyTests::test_dig_axfr_centos_7_7 - AssertionError:...
FAILED tests/test_dig.py::MyTests::test_dig_axfr_osx_10_14_6 - AssertionError...
FAILED tests/test_dig.py::MyTests::test_dig_axfr_ubuntu_18_4 - AssertionError...
FAILED tests/test_dig.py::MyTests::test_dig_centos_7_7 - AssertionError: List...
FAILED tests/test_dig.py::MyTests::test_dig_edns - AssertionError: Lists diff...
FAILED tests/test_dig.py::MyTests::test_dig_edns2 - AssertionError: Lists dif...
FAILED tests/test_dig.py::MyTests::test_dig_edns3 - AssertionError: Lists dif...
FAILED tests/test_dig.py::MyTests::test_dig_nsid - AssertionError: Lists diff...
FAILED tests/test_dig.py::MyTests::test_dig_osx_10_11_6 - AssertionError: Lis...
FAILED tests/test_dig.py::MyTests::test_dig_osx_10_14_6 - AssertionError: Lis...
FAILED tests/test_dig.py::MyTests::test_dig_ubuntu_18_4 - AssertionError: Lis...
FAILED tests/test_dig.py::MyTests::test_dig_x_centos_7_7 - AssertionError: Li...
FAILED tests/test_dig.py::MyTests::test_dig_x_osx_10_11_6 - AssertionError: L...
FAILED tests/test_dig.py::MyTests::test_dig_x_osx_10_14_6 - AssertionError: L...
FAILED tests/test_dig.py::MyTests::test_dig_x_ubuntu_18_4 - AssertionError: L...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10 - AssertionError: List...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10_C - AssertionError: Li...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10_ODTC - AssertionError:...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10_S - AssertionError: Li...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10_dirs - AssertionError:...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10_files - AssertionError...
FAILED tests/test_dir.py::MyTests::test_dir_windows_10_mix - AssertionError: ...
FAILED tests/test_git_log.py::MyTests::test_git_log - AssertionError: Lists d...
FAILED tests/test_git_log.py::MyTests::test_git_log_blank_author_fix - Assert...
FAILED tests/test_git_log.py::MyTests::test_git_log_fuller - AssertionError: ...
FAILED tests/test_git_log.py::MyTests::test_git_log_fuller_hash_in_message_fix
FAILED tests/test_git_log.py::MyTests::test_git_log_fuller_is_hash_fix - Asse...
FAILED tests/test_git_log.py::MyTests::test_git_log_fuller_shortstat - Assert...
FAILED tests/test_git_log.py::MyTests::test_git_log_fuller_stat - AssertionEr...
FAILED tests/test_git_log.py::MyTests::test_git_log_medium - AssertionError: ...
FAILED tests/test_git_log.py::MyTests::test_git_log_medium_shortstat - Assert...
FAILED tests/test_git_log.py::MyTests::test_git_log_medium_stat - AssertionEr...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_blank_author_fix - Asse...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_fuller_hash_in_message_fix
FAILED tests/test_git_log_s.py::MyTests::test_git_log_fuller_is_hash_fix - As...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_fuller_s - AssertionErr...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_fuller_shortstat_s - As...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_fuller_stat_s - Asserti...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_medium_s - AssertionErr...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_medium_shortstat_s - As...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_medium_stat_s - Asserti...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_s - AssertionError: Lis...
FAILED tests/test_git_log_s.py::MyTests::test_git_log_s_ignore_exceptions_success
FAILED tests/test_jc_utils.py::MyTests::test_utils_timestamp - AssertionError...
FAILED tests/test_last.py::MyTests::test_last_F_ubuntu_20_4 - AssertionError:...
FAILED tests/test_last.py::MyTests::test_last_wF_centos_7_7 - AssertionError:...
FAILED tests/test_last.py::MyTests::test_last_wixF_centos_7_7 - AssertionErro...
FAILED tests/test_ls.py::MyTests::test_ls_l_iso_ubuntu_18_4 - AssertionError:...
FAILED tests/test_ls_s.py::MyTests::test_ls_s_l_iso_ubuntu_18_4 - AssertionEr...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine - AssertionError: {'d...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid0_offline - Asser...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid0_ok - AssertionE...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_0_90_ok - Asser...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_checking - Asse...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_failfast - Asse...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_faulty1 - Asser...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_faulty2 - Asser...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_moreflags - Ass...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_ok - AssertionE...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_replacing - Ass...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_resync - Assert...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_spare - Asserti...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid1_syncing - Asser...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid5_homehost - Asse...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid5_meta09 - Assert...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_examine_raid5_ok - AssertionE...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_detail - AssertionError...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid0_ok - AssertionErr...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_failed_and_flags
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_faulty - Assertio...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_faulty_and_removed
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_faulty_with_spare
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_ok - AssertionErr...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_ok_0_9 - Assertio...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_ok_failfast - Ass...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_ok_spare - Assert...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_rebuild_failfast
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_spare_writem_rebuild
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid1_syncing - Asserti...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid5_homehost - Assert...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid5_meta09 - Assertio...
FAILED tests/test_mdadm.py::MyTests::test_mdadm_query_raid5_ok - AssertionErr...
FAILED tests/test_openvpn.py::MyTests::test_openvpn - AssertionError: {'cli[2...
FAILED tests/test_plist.py::MyTests::test_plist_bin_alltypes - AssertionError...
FAILED tests/test_plist.py::MyTests::test_plist_xml_alltypes - AssertionError...
FAILED tests/test_rpm_qai.py::MyTests::test_rpm_qai_centos_7_7 - AssertionErr...
FAILED tests/test_rpm_qai.py::MyTests::test_rpm_qi_package_centos_7_7 - Asser...
FAILED tests/test_rsync.py::MyTests::test_rsync_centos_7_7_rsync_i_logfile - ...
FAILED tests/test_rsync.py::MyTests::test_rsync_centos_7_7_rsync_i_v_logfile
FAILED tests/test_rsync.py::MyTests::test_rsync_centos_7_7_rsync_i_vv_logfile
FAILED tests/test_rsync.py::MyTests::test_rsync_centos_7_7_rsync_i_vvv_logfile
FAILED tests/test_rsync.py::MyTests::test_rsync_centos_7_7_rsync_i_vvv_logfile_nochange
FAILED tests/test_rsync.py::MyTests::test_rsync_osx_10_14_6_rsync_i_vvv_logfile_nochange
FAILED tests/test_rsync_s.py::MyTests::test_rsync_s_i_logfile_centos_7_7 - As...
FAILED tests/test_rsync_s.py::MyTests::test_rsync_s_i_v_logfile_centos_7_7 - ...
FAILED tests/test_rsync_s.py::MyTests::test_rsync_s_i_vv_logfile_centos_7_7
FAILED tests/test_rsync_s.py::MyTests::test_rsync_s_i_vvv_logfile_centos_7_7
FAILED tests/test_rsync_s.py::MyTests::test_rsync_s_i_vvv_logfile_nochange_centos_7_7
FAILED tests/test_rsync_s.py::MyTests::test_rsync_s_i_vvv_logfile_nochange_osx_10_14_6
FAILED tests/test_stat.py::MyTests::test_stat_centos_7_7 - AssertionError: Li...
FAILED tests/test_stat.py::MyTests::test_stat_filename_with_spaces_osx_10_14_6
FAILED tests/test_stat.py::MyTests::test_stat_freebsd12 - AssertionError: Lis...
FAILED tests/test_stat.py::MyTests::test_stat_missing_data - AssertionError: ...
FAILED tests/test_stat.py::MyTests::test_stat_osx_10_14_6 - AssertionError: L...
FAILED tests/test_stat.py::MyTests::test_stat_ubuntu_18_4 - AssertionError: L...
FAILED tests/test_stat_s.py::MyTests::test_stat_s_centos_7_7 - AssertionError...
FAILED tests/test_stat_s.py::MyTests::test_stat_s_filename_with_spaces_osx_10_14_6
FAILED tests/test_stat_s.py::MyTests::test_stat_s_freebsd12 - AssertionError:...
FAILED tests/test_stat_s.py::MyTests::test_stat_s_osx_10_14_6 - AssertionErro...
FAILED tests/test_stat_s.py::MyTests::test_stat_s_ubuntu_18_4 - AssertionErro...
FAILED tests/test_syslog.py::MyTests::test_syslog_sample - AssertionError: Li...
FAILED tests/test_syslog_s.py::MyTests::test_syslog_s - AssertionError: Lists...
FAILED tests/test_systeminfo.py::MyTests::test_windows_systeminfo - Assertion...
FAILED tests/test_timestamp.py::MyTests::test_10_digit_timestamp - AssertionE...
FAILED tests/test_timestamp.py::MyTests::test_13_digit_timestamp - AssertionE...
FAILED tests/test_tune2fs.py::MyTests::test_tune2fs_l - AssertionError: {'ver...
FAILED tests/test_upower.py::MyTests::test_upower_d_clocale_ubuntu_18_4 - Ass...
FAILED tests/test_upower.py::MyTests::test_upower_d_ubuntu_18_4 - AssertionEr...
FAILED tests/test_upower.py::MyTests::test_upower_i_c_locale - AssertionError...
FAILED tests/test_upower.py::MyTests::test_upower_i_non_utc_generic - Asserti...
FAILED tests/test_upower.py::MyTests::test_upower_i_ubuntu_18_4 - AssertionEr...
FAILED tests/test_upower.py::MyTests::test_upower_i_utc_generic - AssertionEr...
FAILED tests/test_vmstat.py::MyTests::test_vmstat_at_5_10 - AssertionError: L...
FAILED tests/test_vmstat.py::MyTests::test_vmstat_awt - AssertionError: Lists...
FAILED tests/test_vmstat.py::MyTests::test_vmstat_dt - AssertionError: Lists ...
FAILED tests/test_vmstat_s.py::MyTests::test_vmstat_s_at_5_10_centos_7_7 - As...
FAILED tests/test_vmstat_s.py::MyTests::test_vmstat_s_awt_centos_7_7 - Assert...
FAILED tests/test_vmstat_s.py::MyTests::test_vmstat_s_dt_centos_7_7 - Asserti...
FAILED tests/test_who.py::MyTests::test_who_a_centos_7_7 - AssertionError: Li...
FAILED tests/test_who.py::MyTests::test_who_a_ubuntu_18_4 - AssertionError: L...
FAILED tests/test_who.py::MyTests::test_who_centos_7_7 - AssertionError: List...
FAILED tests/test_who.py::MyTests::test_who_login_screen - AssertionError: Li...
FAILED tests/test_who.py::MyTests::test_who_ubuntu_18_4 - AssertionError: Lis...
============ 152 failed, 1287 passed, 1 skipped in 71.70s (0:01:11) ============
from jc.
kellyjonbrazil commented on August 12, 2024
Hi there!
Yes, this is expected since jc performs naive and aware timestamp tests so the correct timezone must be set prior to tests.
Prepend TZ="America/Los_Angeles" to your test command and test should pass. Thanks!
from jc.
kloczek commented on August 12, 2024
OK so why this env variable is not set in pytest session? 🤔
from jc.
kellyjonbrazil commented on August 12, 2024
Mostly because it’s documented to work this way and there isn’t a clean method to change the time zone in a safe way on Windows, so I leave it to the tester.
from jc.
kloczek commented on August 12, 2024
Here is possible way how to solve that:
https://stackoverflow.com/questions/36141024/how-to-pass-environment-variables-to-pytest
https://pytest-with-eric.com/pytest-best-practices/pytest-environment-variables/
from jc.
kellyjonbrazil commented on August 12, 2024
There's not so much an issue of getting the environment variable into the tests, rather the issue is how to cleanly set the timezone in the OS during the test. It's fairly trivial in Linux/Unix because the shell just uses the TZ env variable to set the timezone for the session (and only that session). That's why TZ="America/Los_Angeles" python3 -m unittest -v works.
Unfortunately, there is no analog in Windows, and if we change the timezone during the test it changes the timezone for the whole system, which could put the system in a weird state for the user while the test is running. That is why it's left up to the tester so it is explicit and there are no surprises.
For example, in Github Actions we use szenius/set-timezone to set the timezone for the OS (linux, macOS, or Windows) before running the tests.
Also, we use unittest instead of pytest, though it seems pytest may be able to run unittests? I'm not sure as I've not used pytest before.
from jc.
kloczek commented on August 12, 2024
That's why TZ="America/Los_Angeles" python3 -m unittest -v works.
What is the problem with add that en variable in pytest configuration?
Documentation about that takes more characters than entry in pytest configuration.
If you want to have more tickets like mine that is OK.
And unittest .. correctly written unittest based test suite can be handled correctly by pytest.
unittest provides as well setting up env variables in test suite code/settings.
Nothing here needs to be documented. All what is needed is correct setup/test suite settings.
from jc.
kellyjonbrazil commented on August 12, 2024
What is the problem with add that en variable in pytest configuration?
Adding the env variable within python does not change the timezone. There is some magic in the shell that does this based on the value of the TZ environment variable. That's why it is best to set it before running the tests.
Yes, it is possible to set the timezone in python, but again, not in a consistent way across platforms. If jc were only a linux cli tool then I would just do that in the tests. jc is packaged on dozens of distros and platforms and this question does occasionally come up. Once I point them to the docs it doesn't seem to be a problem going forward.
from jc.
1.25.3: pytest fails in nits which are comparing time about jc HOT 8 CLOSED

Comments (8)

Related Issues (20)

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent
