1 files changed, 29 insertions, 29 deletions

diff --git a/tests/richstring_test.py b/tests/richstring_test.py
index dd64112..e9f3a32 100644
--- a/tests/richstring_test.py
+++ b/tests/richstring_test.py
@@ -26,25 +26,25 @@ class RichStringOperatorTests(TestCase):
 
     def test_repr(self):
         s = bold('Hello') + plain(' there ') + bold('folks')
-        self.assertEquals(
+        self.assertEqual(
             "(bold)('Hello') + (plain)(' there ') + (bold)('folks')",
             repr(s)
         )
 
     def test_repr_on_empty_string(self):
-        self.assertEquals('empty_string', repr(empty_string))
+        self.assertEqual('empty_string', repr(empty_string))
 
     def test_unicode(self):
         s = bold('Hello') + plain(' there ') + bold('folks')
-        self.assertEquals(
+        self.assertEqual(
             u'Hello there folks',
             str(s)
         )
 
     def test_eq(self):
-        self.assertEquals(bold('Hello'), bold('Hello'))
-        self.assertNotEquals(bold('Hello'), bold('Foo'))
-        self.assertNotEquals(plain('Hello'), bold('Hello'))
+        self.assertEqual(bold('Hello'), bold('Hello'))
+        self.assertNotEqual(bold('Hello'), bold('Foo'))
+        self.assertNotEqual(plain('Hello'), bold('Hello'))
 
     def test_ne(self):
         self.assertFalse(bold('Hello') != bold('Hello'))
@@ -54,19 +54,19 @@ class RichStringOperatorTests(TestCase):
         s1 = plain('hello')
         s2 = bold(' there')
         result = s1 + s2
-        self.assertEquals(expected, result)
+        self.assertEqual(expected, result)
 
 
 class StyleGeneratorTests(TestCase):
 
     def test_bold_function_creates_bold_richstring(self):
-        self.assertEquals(
+        self.assertEqual(
             RichString(Segment('a', (Bold,))),
             bold('a')
         )
 
     def test_adding_functions(self):
-        self.assertEquals(
+        self.assertEqual(
             RichString(Segment('a', (Bold, Italic))),
             (bold + italic)('a')
         )
@@ -75,14 +75,14 @@ class StyleGeneratorTests(TestCase):
 class RichStringTests(TestCase):
 
     def test_plain_to_html(self):
-        self.assertEquals('hello', plain('hello').to_html())
+        self.assertEqual('hello', plain('hello').to_html())
 
     def test_to_html(self):
         s = (
             bold('bold') + plain(' normal ') +
             italic('italic') + underline('wonderline')
         )
-        self.assertEquals(
+        self.assertEqual(
             '<strong>bold</strong> normal <em>italic</em><u>wonderline</u>',
             s.to_html()
         )
@@ -91,72 +91,72 @@ class RichStringTests(TestCase):
 class ParseEmphasisTests(TestCase):
 
     def test_parse_without_emphasis(self):
-        self.assertEquals(
+        self.assertEqual(
             plain('Hello'), parse_emphasis('Hello'),
             'Expected parse_emphasis to return a plain string')
 
     def test_parse_bold(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('**Hello**'),
             bold('Hello')
         )
 
     def test_parse_pre_and_postfix_and_bold(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('pre**Hello**post'),
             plain('pre') + bold('Hello') + plain('post')
         )
 
     def test_parse_multiple_bold(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('x**Hello** **there**'),
             plain('x') + bold('Hello') + plain(' ') + bold('there')
         )
 
     def test_parse_adjacent_bold(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('**123**456**'),
             bold('123') + plain('456**')
         )
 
     def test_italic(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('*Italian style*'),
             italic('Italian style')
         )
 
     def test_bold_inside_italic(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('*Swedish **style** rules*'),
             italic('Swedish ') + (bold + italic)('style') + italic(' rules')
         )
 
     def test_italic_inside_bold(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('**Swedish *style* rules**'),
             bold('Swedish ') + (bold + italic)('style') + bold(' rules')
         )
 
     def test_italic_and_bold(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('***really strong***'),
             (bold + italic)('really strong')
         )
 
     def test_additional_star(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('*foo* bar* baz'),
             italic('foo') + plain(' bar* baz')
         )
 
     def test_underline(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('_hello_'),
             underline('hello')
         )
 
     def test_bold_inside_underline(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('_**hello**_'),
             (bold + underline)('hello')
         )
@@ -164,14 +164,14 @@ class ParseEmphasisTests(TestCase):
     def test_overlapping_underscore_and_italic(self):
         # It's unclear what result to expect in this case.
         # This is one way of interpreting it
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('_*he_llo*'),
             (italic + underline)('he') + italic('llo')
         )
 
     def test_complicated(self):
         # As reported by Stu
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis(
                 'You can _underline_ words, make them **bold** or *italic* '
                 'or even ***bold italic.***'
@@ -184,26 +184,26 @@ class ParseEmphasisTests(TestCase):
         )
 
     def test_simplified_complicated(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('*italic* or even ***bold italic.***'),
             italic('italic') + plain(' or even ') +
             (bold + italic)('bold italic.')
         )
 
     def test_two_italic_should_not_create_one_long_italic_string(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('*first* *second*'),
             italic('first') + plain(' ') + italic('second')
         )
 
     def test_two_bold_should_not_create_one_long_bold_string(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis('**first** **second**'),
             bold('first') + plain(' ') + bold('second')
         )
 
     def test_escaping_star_creates_a_literal_star(self):
-        self.assertEquals(
+        self.assertEqual(
             parse_emphasis(r'\*hello*'),
             plain('*hello*')
         )