def test_iso_format(self):
     """Test conversion from and to ISO format."""
     t1 = Timestamp.utcnow()
     ts1 = t1.isoformat()
     t2 = Timestamp.fromISOformat(ts1)
     ts2 = t2.isoformat()
     # MediaWiki ISO format doesn't include microseconds
     self.assertNotEqual(t1, t2)
     t1 = t1.replace(microsecond=0)
     self.assertEqual(t1, t2)
     self.assertEqual(ts1, ts2)

 def test_iso_format_with_sep(self):
     """Test conversion from and to ISO format with separator."""
     SEP = '*'
     t1 = Timestamp.utcnow().replace(microsecond=0)
     ts1 = t1.isoformat(sep=SEP)
     t2 = Timestamp.fromISOformat(ts1, sep=SEP)
     ts2 = t2.isoformat(sep=SEP)
     self.assertEqual(t1, t2)
     self.assertEqual(t1, t2)
     self.assertEqual(ts1, ts2)
     date, sep, time = ts1.partition(SEP)
     time = time.rstrip('Z')
     self.assertEqual(date, str(t1.date()))
     self.assertEqual(time, str(t1.time()))

 def test_iso_format(self):
     """Test conversion from and to ISO format."""
     SEP = 'T'
     t1 = Timestamp.utcnow()
     ts1 = t1.isoformat()
     t2 = Timestamp.fromISOformat(ts1)
     ts2 = t2.isoformat()
     # MediaWiki ISO format doesn't include microseconds
     self.assertNotEqual(t1, t2)
     t1 = t1.replace(microsecond=0)
     self.assertEqual(t1, t2)
     self.assertEqual(ts1, ts2)
     date, sep, time = ts1.partition(SEP)
     time = time.rstrip('Z')
     self.assertEqual(date, str(t1.date()))
     self.assertEqual(time, str(t1.time()))

 def test_build_table_with_check(self):
     """Test buildt table with check option."""
     bot = imagereview.CheckImageBot(check=True, total=0)
     bot.cat = 'Nonexisting page for imagereview'
     table = bot.build_table(save=False, unittest=True)
     if not table:
         self.skipTest('Table of files to review is empty')
     key = list(table.keys())[0]  # py3 comp
     data = table[key]
     item = data[0]
     self.assertIsInstance(key, StringTypes)
     self.assertIsInstance(data, list)
     self.assertIsInstance(item, list)
     self.assertEqual(len(item), 4)
     linkedtitle, uploader, filepage, reason = item
     user, time = uploader
     self.assertIsInstance(linkedtitle, StringTypes)
     self.assertIsInstance(uploader, list)
     self.assertIsInstance(filepage, imagereview.DUP_Image)
     self.assertIsInstance(reason, StringTypes)
     self.assertIsInstance(user, StringTypes)
     self.assertIsInstance(time, StringTypes)
     self.assertEqual(reason, '')
     self.assertEqual(filepage.title(asLink=True, textlink=True),
                      linkedtitle)
     self.assertEqual(user, key)
     self.assertIsInstance(Timestamp.fromISOformat(time), Timestamp)

 def test_sub_timedate(self):
     """Test subtracting two timestamps."""
     t1 = Timestamp.utcnow()
     t2 = t1 - datetime.timedelta(days=1)
     td = t1 - t2
     self.assertIsInstance(td, datetime.timedelta)
     self.assertEqual(t2 + td, t1)

 def test_sub_timedelta(self):
     """Test substracting a timedelta from a Timestamp."""
     t1 = Timestamp.utcnow()
     t2 = t1 - datetime.timedelta(days=1)
     if t1.month != t2.month:
         self.assertEqual(calendar.monthrange(t2.year, t2.month)[1], t2.day)
     else:
         self.assertEqual(t1.day - 1, t2.day)
     self.assertIsInstance(t2, Timestamp)

 def test_add_timedelta(self):
     """Test addin a timedelta to a Timestamp."""
     t1 = Timestamp.utcnow()
     t2 = t1 + datetime.timedelta(days=1)
     if t1.month != t2.month:
         self.assertEqual(1, t2.day)
     else:
         self.assertEqual(t1.day + 1, t2.day)
     self.assertIsInstance(t2, Timestamp)

 def test_instantiate_from_instance(self):
     """Test passing instance to factory methods works."""
     t1 = Timestamp.utcnow()
     self.assertIsNot(t1, Timestamp.fromISOformat(t1))
     self.assertEqual(t1, Timestamp.fromISOformat(t1))
     self.assertIsInstance(Timestamp.fromISOformat(t1), Timestamp)
     self.assertIsNot(t1, Timestamp.fromtimestampformat(t1))
     self.assertEqual(t1, Timestamp.fromtimestampformat(t1))
     self.assertIsInstance(Timestamp.fromtimestampformat(t1), Timestamp)

    def test_add_timedate(self):
        """Test unsupported additions raise NotImplemented."""
        t1 = datetime.datetime.utcnow()
        t2 = t1 + datetime.timedelta(days=1)
        t3 = t1.__add__(t2)
        self.assertIs(t3, NotImplemented)

        # Now check that the pywikibot sub-class behaves the same way
        t1 = Timestamp.utcnow()
        t2 = t1 + datetime.timedelta(days=1)
        t3 = t1.__add__(t2)
        self.assertIs(t3, NotImplemented)

    def run(self):
        """Run the bot."""
        starttime = time()
        rc_listener = site_rc_listener(self.site, timeout=60)
        while True:
            pywikibot.output(Timestamp.now().strftime(">> %H:%M:%S: "))
            self.read_lists()
            try:
                self.markBlockedusers(self.loadBlockedUsers())
                self.contactDefendants(bootmode=self.start)
            except pywikibot.EditConflict:
                pywikibot.output("Edit conflict found, try again.")
                continue  # try again and skip waittime
            except pywikibot.PageNotSaved:
                pywikibot.output("Page not saved, try again.")
                continue  # try again and skip waittime

            # wait for new block entry
            print()
            now = time()
            pywikibot.stopme()
            for i, entry in enumerate(rc_listener):
                if i % 25 == 0:
                    print('\r', ' ' * 50, '\rWaiting for events', end='')
                if entry['type'] == 'log' and \
                   entry['log_type'] == 'block' and \
                   entry['log_action'] in ('block', 'reblock'):
                    pywikibot.output('\nFound a new blocking event '
                                     'by user "%s" for user "%s"'
                                     % (entry['user'], entry['title']))
                    break
                if entry['type'] == 'edit' and \
                   not entry['bot'] and \
                   entry['title'] == self.vmPageName:
                    pywikibot.output('\nFound a new edit by user "%s"'
                                     % entry['user'])
                    break
                if not entry['bot']:
                    print('.', end='')
            print('\n')

            self.optOutListAge += time() - now

            # read older entries again after ~4 minutes
            if time() - starttime > 250:
                starttime = time()
                self.reset_timestamp()
            self.start = False
            self.total = 10

 def test_clone(self):
     """Test cloning a Timestamp instance."""
     t1 = Timestamp.utcnow()
     t2 = t1.clone()
     self.assertEqual(t1, t2)
     self.assertIsInstance(t2, Timestamp)

 def test_iso_format_property(self):
     """Test iso format properties."""
     self.assertEqual(Timestamp.ISO8601Format, Timestamp._ISO8601Format())
     self.assertEqual(re.sub(r'[\-:TZ]', '', Timestamp.ISO8601Format),
                      Timestamp.mediawikiTSFormat)

 def test_mediawiki_format(self):
     t1 = T.utcnow()
     ts1 = t1.totimestampformat()
     t2 = T.fromtimestampformat(ts1)
     ts2 = t2.totimestampformat()
     # MediaWiki timestamp format doesn't include microseconds
     self.assertNotEqual(t1, t2)
     t1 = t1.replace(microsecond=0)
     self.assertEqual(t1, t2)
     self.assertEqual(ts1, ts2)

 def test_iso_format(self):
     t1 = T.utcnow()
     ts1 = t1.toISOformat()
     t2 = T.fromISOformat(ts1)
     ts2 = t2.toISOformat()
     # MediaWiki ISO format doesn't include microseconds
     self.assertNotEqual(t1, t2)
     t1 = t1.replace(microsecond=0)
     self.assertEqual(t1, t2)
     self.assertEqual(ts1, ts2)

 def test_add_timedelta(self):
     t1 = T.utcnow()
     t2 = t1 + datetime.timedelta(days=1)
     if t1.month != t2.month:
         self.assertEqual(1, t2.day)
     else:
         self.assertEqual(t1.day + 1, t2.day)
     self.assertIsInstance(t2, T)

 def test_sub_timedelta(self):
     t1 = T.utcnow()
     t2 = t1 - datetime.timedelta(days=1)
     if t1.month != t2.month:
         self.assertEqual(calendar.monthrange(t2.year, t2.month)[1], t2.day)
     else:
         self.assertEqual(t1.day - 1, t2.day)
     self.assertIsInstance(t2, T)

 def test_sub_timedelta(self):
     t1 = T.utcnow()
     t2 = t1 - datetime.timedelta(days=1)
     self.assertEqual(t1.day - 1, t2.day)
     self.assertIsInstance(t2, T)

 def test_sub_timedate(self):
     t1 = T.utcnow()
     t2 = t1 - datetime.timedelta(days=1)
     td = t1 - t2
     self.assertIsInstance(td, datetime.timedelta)
     self.assertEqual(t2 + td, t1)

 def test_clone(self):
     t1 = T.utcnow()
     t2 = t1.clone()
     self.assertEqual(t1, t2)
     self.assertIsInstance(t2, T)