def test_set_priority6(self):
        """ Do not set priorities on completed tasks. """
        todo = TodoBase("x 2014-06-13 Foo")
        todo.set_priority('A')

        self.assertFalse(todo.priority())
        self.assertEqual(todo.src, "x 2014-06-13 Foo")

    def test_set_priority2(self):
        """ Set priority to task without priority. """
        todo = TodoBase("Foo")
        todo.set_priority('B')

        self.assertEqual(todo.priority(), 'B')
        self.assertTrue(re.match(r'^\(B\) Foo$', todo.src))

    def test_set_priority5(self):
        """ Unset priority. """
        todo = TodoBase("(A) Foo")
        todo.set_priority(None)

        self.assertEqual(todo.priority(), None)
        self.assertTrue(re.match(r'^Foo$', todo.src))

    def test_set_priority3(self):
        """ Test invalid priority input. """
        todo = TodoBase("(A) Foo")
        todo.set_priority('AB')

        self.assertEqual(todo.priority(), 'A')
        self.assertTrue(re.match(r'^\(A\) Foo$', todo.src))

    def test_remove_all(self):
        todo = TodoBase("(C) Foo foo:bar foo:baz foo:")
        todo.remove_tag('foo')

        self.assertFalse(todo.has_tag('foo'))
        self.assertFalse(re.search(r'\bfoo:(bar|baz)\b', todo.src))
        self.assertTrue(re.search(r'foo:', todo.src))

    def test_set_priority1(self):
        """ Change priority. """
        todo = TodoBase("(A) Foo")
        todo.set_priority('B')

        self.assertEqual(todo.priority(), 'B')
        self.assertTrue(re.match(r'^\(B\) Foo$', todo.src))

    def test_set_tag_double_tag(self):
        todo = TodoBase("(C) Foo foo:bar foo:baz")
        todo.set_tag('foo', 'blah')

        self.assertTrue(todo.has_tag('foo', 'blah'))
        self.assertTrue(todo.has_tag('foo', 'bar') or
                        todo.has_tag('foo', 'baz'))

 def test_set_creation_date7(self):
     """
     A todo item with an invalid creation date is not considered to have
     one.
     """
     todo = TodoBase("x 2017-07-01 2017-06-31 Invalid")
     self.assertIsNone(todo.creation_date())

    def test_set_source_text(self):
        todo = TodoBase("(B) Foo")

        new_text = "(C) Foo"
        todo.set_source_text(new_text)

        self.assertEqual(todo.src, new_text)
        self.assertEqual(todo.priority(),'C')

    def test_set_creation_date5(self):
        todo = TodoBase("x 2014-07-25 2014-07-23 Foo")
        creation_date = date(2014, 7, 24)

        todo.set_creation_date(creation_date)

        self.assertEqual(todo.creation_date(), creation_date)
        self.assertEqual(todo.src, "x 2014-07-25 2014-07-24 Foo")

    def test_set_complete4(self):
        todo = TodoBase("(A) 2014-06-12 Foo")
        todo.set_completed()

        today = date.today()
        today_str = today.isoformat()

        self.assertEqual(todo.fields['completionDate'], today)
        self.assertTrue(re.match('^x ' + today_str + ' 2014-06-12 Foo', todo.src))

    def test_completion5(self):
        """
        A todo item with an invalid completion date is still considered as
        completed, but without a creation date.
        """
        todo = TodoBase("x 2017-06-31 Invalid date")

        self.assertTrue(todo.is_completed())
        self.assertIsNone(todo.completion_date())

    def test_set_complete1(self):
        todo = TodoBase("(A) Foo")
        todo.set_completed()

        today = date.today()
        today_str = today.isoformat()

        self.assertFalse(todo.priority())
        self.assertEqual(todo.fields['completionDate'], today)
        self.assertTrue(re.match('^x ' + today_str + ' Foo', todo.src))

    def test_set_priority4(self):
        """ Add priority, while not be mistaken about todo string. """
        todo = TodoBase("(A)Foo")

        self.assertNotEqual(todo.priority(), 'A')

        todo.set_priority('B')

        self.assertEqual(todo.priority(), 'B')
        self.assertTrue(re.match(r'^\(B\) \(A\)Foo$', todo.src))

    def test_set_tag_double_value(self):
        todo = TodoBase("(C) Foo foo:bar baz:bar")
        todo.set_tag('foo', 'blah');

        self.assertTrue(todo.has_tag('foo'))
        self.assertTrue(todo.tag_value('foo'), 'blah')
        self.assertTrue(todo.has_tag('baz'))
        self.assertTrue(todo.tag_value('baz'), 'bar')

    def test_add_tag1(self):
        todo = TodoBase("(C) Foo")
        todo.set_tag('foo', 'bar')

        self.assertTrue(todo.has_tag('foo'))
        self.assertTrue(todo.has_tag('foo', 'bar'))
        self.assertFalse(todo.has_tag('foo', 'baz'))
        self.assertFalse(todo.has_tag('bar'))
        self.assertTrue(re.search(r'\bfoo:bar\b', todo.src))

    def test_set_tag2(self):
        todo = TodoBase("(C) Foo foo:bar foo:baz")
        todo.set_tag('foo', 'bang', False, 'baz')

        self.assertTrue(todo.has_tag('foo'))
        self.assertTrue(todo.has_tag('foo', 'bar'))
        self.assertTrue(todo.has_tag('foo', 'bang'))
        self.assertFalse(todo.has_tag('foo', 'baz'))

        self.assertTrue(re.search(r'\bfoo:bar\b', todo.src))
        self.assertFalse(re.search(r'\bfoo:baz\b', todo.src))

    def test_remove_specific_tag_value(self):
        todo = TodoBase("(C) Foo kungfoo:bar foo:bar foo:barz")
        todo.remove_tag('foo', 'bar')

        self.assertTrue(todo.has_tag('foo'))
        self.assertTrue(todo.has_tag('kungfoo', 'bar'))
        self.assertTrue(todo.has_tag('foo', 'barz'))
        self.assertFalse(todo.has_tag('foo', 'bar'))

        self.assertTrue(re.search(r'\bkungfoo:bar\b', todo.src))
        self.assertTrue(re.search(r'\bfoo:barz\b', todo.src))
        self.assertFalse(re.search(r'\bfoo:bar\b', todo.src))

    def test_parse_tag(self):
        todo = TodoBase("(C) Test foo:bar foo:baz foo_:baz_ blah:zah:haz")

        self.assertTrue(todo.has_tag('foo'))
        self.assertTrue(todo.has_tag('foo_'))
        self.assertTrue(todo.has_tag('foo', 'bar'))
        self.assertTrue(todo.has_tag('foo', 'baz'))
        self.assertTrue(todo.has_tag('blah'))
        self.assertTrue(todo.has_tag('blah', 'zah:haz'))

    def test_context2(self):
        todo = TodoBase("(C) Foo @Bar+Baz")

        self.assertEqual(len(todo.contexts()), 1)
        self.assertIn('Bar+Baz', todo.contexts())