A"""
+ soup = self.soup(markup)
+- self.assertEqual(u"A", soup.body.decode())
++ self.assertEqual("A", soup.body.decode())
+
+ def test_extraction(self):
+ """
+diff --git a/bs4/tests/test_htmlparser.py b/bs4/tests/test_htmlparser.py
+index 7ee91aa..aeff094 100644
+--- a/bs4/tests/test_htmlparser.py
++++ b/bs4/tests/test_htmlparser.py
+@@ -60,20 +60,20 @@ class HTMLParserTreeBuilderSmokeTest(SoupTest, HTMLTreeBuilderSmokeTest):
+ # If you don't provide any particular value for
+ # on_duplicate_attribute, later values replace earlier values.
+ soup = self.soup(markup)
+- self.assertEquals("url3", soup.a['href'])
+- self.assertEquals(["cls"], soup.a['class'])
+- self.assertEquals("id", soup.a['id'])
++ self.assertEqual("url3", soup.a['href'])
++ self.assertEqual(["cls"], soup.a['class'])
++ self.assertEqual("id", soup.a['id'])
+
+ # You can also get this behavior explicitly.
+ def assert_attribute(on_duplicate_attribute, expected):
+ soup = self.soup(
+ markup, on_duplicate_attribute=on_duplicate_attribute
+ )
+- self.assertEquals(expected, soup.a['href'])
++ self.assertEqual(expected, soup.a['href'])
+
+ # Verify that non-duplicate attributes are treated normally.
+- self.assertEquals(["cls"], soup.a['class'])
+- self.assertEquals("id", soup.a['id'])
++ self.assertEqual(["cls"], soup.a['class'])
++ self.assertEqual("id", soup.a['id'])
+ assert_attribute(None, "url3")
+ assert_attribute(BeautifulSoupHTMLParser.REPLACE, "url3")
+
+diff --git a/bs4/tests/test_lxml.py b/bs4/tests/test_lxml.py
+index f96e4ae..3d0c75f 100644
+--- a/bs4/tests/test_lxml.py
++++ b/bs4/tests/test_lxml.py
+@@ -7,7 +7,7 @@ try:
+ import lxml.etree
+ LXML_PRESENT = True
+ LXML_VERSION = lxml.etree.LXML_VERSION
+-except ImportError, e:
++except ImportError as e:
+ LXML_PRESENT = False
+ LXML_VERSION = (0,)
+
+@@ -68,7 +68,7 @@ class LXMLTreeBuilderSmokeTest(SoupTest, HTMLTreeBuilderSmokeTest):
+ # if one is installed.
+ with warnings.catch_warnings(record=True) as w:
+ soup = BeautifulStoneSoup("")
+- self.assertEqual(u"", unicode(soup.b))
++ self.assertEqual("", str(soup.b))
+ self.assertTrue("BeautifulStoneSoup class is deprecated" in str(w[0].message))
+
+ def test_tracking_line_numbers(self):
+diff --git a/bs4/tests/test_soup.py b/bs4/tests/test_soup.py
+index 857eb41..e1035ea 100644
+--- a/bs4/tests/test_soup.py
++++ b/bs4/tests/test_soup.py
+@@ -51,17 +51,17 @@ PYTHON_3_PRE_3_2 = (sys.version_info[0] == 3 and sys.version_info < (3,2))
+ class TestConstructor(SoupTest):
+
+ def test_short_unicode_input(self):
+- data = u"éé"
++ data = "éé"
+ soup = self.soup(data)
+- self.assertEqual(u"éé", soup.h1.string)
++ self.assertEqual("éé", soup.h1.string)
+
+ def test_embedded_null(self):
+- data = u"foo\0bar"
++ data = "foo\0bar"
+ soup = self.soup(data)
+- self.assertEqual(u"foo\0bar", soup.h1.string)
++ self.assertEqual("foo\0bar", soup.h1.string)
+
+ def test_exclude_encodings(self):
+- utf8_data = u"Räksmörgås".encode("utf-8")
++ utf8_data = "Räksmörgås".encode("utf-8")
+ soup = self.soup(utf8_data, exclude_encodings=["utf-8"])
+ self.assertEqual("windows-1252", soup.original_encoding)
+
+@@ -127,7 +127,7 @@ class TestConstructor(SoupTest):
+ yield markup, None, None, False
+
+ import re
+- self.assertRaisesRegexp(
++ self.assertRaisesRegex(
+ ParserRejectedMarkup,
+ "The markup you provided was rejected by the parser. Trying a different parser or a different encoding may help.",
+ BeautifulSoup, '', builder=Mock,
+@@ -303,7 +303,7 @@ class TestWarnings(SoupTest):
+ with warnings.catch_warnings(record=True) as warning_list:
+ # note - this url must differ from the bytes one otherwise
+ # python's warnings system swallows the second warning
+- soup = self.soup(u"http://www.crummyunicode.com/")
++ soup = self.soup("http://www.crummyunicode.com/")
+ warning = self._assert_warning(
+ warning_list, MarkupResemblesLocatorWarning
+ )
+@@ -319,7 +319,7 @@ class TestWarnings(SoupTest):
+
+ def test_url_warning_with_unicode_and_space(self):
+ with warnings.catch_warnings(record=True) as warning_list:
+- soup = self.soup(u"http://www.crummyuncode.com/ is great")
++ soup = self.soup("http://www.crummyuncode.com/ is great")
+ self.assertFalse(any("looks like a URL" in str(w.message)
+ for w in warning_list))
+
+@@ -341,9 +341,9 @@ class TestEntitySubstitution(unittest.TestCase):
+ def test_simple_html_substitution(self):
+ # Unicode characters corresponding to named HTML entites
+ # are substituted, and no others.
+- s = u"foo\u2200\N{SNOWMAN}\u00f5bar"
++ s = "foo\u2200\N{SNOWMAN}\u00f5bar"
+ self.assertEqual(self.sub.substitute_html(s),
+- u"foo∀\N{SNOWMAN}õbar")
++ "foo∀\N{SNOWMAN}õbar")
+
+ def test_smart_quote_substitution(self):
+ # MS smart quotes are a common source of frustration, so we
+@@ -408,7 +408,7 @@ class TestEncodingConversion(SoupTest):
+
+ def setUp(self):
+ super(TestEncodingConversion, self).setUp()
+- self.unicode_data = u'Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!'
++ self.unicode_data = 'Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!'
+ self.utf8_data = self.unicode_data.encode("utf-8")
+ # Just so you know what it looks like.
+ self.assertEqual(
+@@ -428,7 +428,7 @@ class TestEncodingConversion(SoupTest):
+ ascii = b"a"
+ soup_from_ascii = self.soup(ascii)
+ unicode_output = soup_from_ascii.decode()
+- self.assertTrue(isinstance(unicode_output, unicode))
++ self.assertTrue(isinstance(unicode_output, str))
+ self.assertEqual(unicode_output, self.document_for(ascii.decode()))
+ self.assertEqual(soup_from_ascii.original_encoding.lower(), "utf-8")
+ finally:
+@@ -440,7 +440,7 @@ class TestEncodingConversion(SoupTest):
+ # is not set.
+ soup_from_unicode = self.soup(self.unicode_data)
+ self.assertEqual(soup_from_unicode.decode(), self.unicode_data)
+- self.assertEqual(soup_from_unicode.foo.string, u'Sacr\xe9 bleu!')
++ self.assertEqual(soup_from_unicode.foo.string, 'Sacr\xe9 bleu!')
+ self.assertEqual(soup_from_unicode.original_encoding, None)
+
+ def test_utf8_in_unicode_out(self):
+@@ -448,7 +448,7 @@ class TestEncodingConversion(SoupTest):
+ # attribute is set.
+ soup_from_utf8 = self.soup(self.utf8_data)
+ self.assertEqual(soup_from_utf8.decode(), self.unicode_data)
+- self.assertEqual(soup_from_utf8.foo.string, u'Sacr\xe9 bleu!')
++ self.assertEqual(soup_from_utf8.foo.string, 'Sacr\xe9 bleu!')
+
+ def test_utf8_out(self):
+ # The internal data structures can be encoded as UTF-8.
+@@ -459,7 +459,7 @@ class TestEncodingConversion(SoupTest):
+ PYTHON_3_PRE_3_2,
+ "Bad HTMLParser detected; skipping test of non-ASCII characters in attribute name.")
+ def test_attribute_name_containing_unicode_characters(self):
+- markup = u''
++ markup = ''
+ self.assertEqual(self.soup(markup).div.encode("utf8"), markup.encode("utf8"))
+
+ class TestUnicodeDammit(unittest.TestCase):
+@@ -526,7 +526,7 @@ class TestUnicodeDammit(unittest.TestCase):
+
+ def test_exclude_encodings(self):
+ # This is UTF-8.
+- utf8_data = u"Räksmörgås".encode("utf-8")
++ utf8_data = "Räksmörgås".encode("utf-8")
+
+ # But if we exclude UTF-8 from consideration, the guess is
+ # Windows-1252.
+diff --git a/bs4/tests/test_tree.py b/bs4/tests/test_tree.py
+index 2246346..b4f2a86 100644
+--- a/bs4/tests/test_tree.py
++++ b/bs4/tests/test_tree.py
+@@ -75,13 +75,13 @@ class TestFind(TreeTest):
+ self.assertEqual(soup.find("b").string, "2")
+
+ def test_unicode_text_find(self):
+- soup = self.soup(u'Räksmörgås')
+- self.assertEqual(soup.find(string=u'Räksmörgås'), u'Räksmörgås')
++ soup = self.soup('Räksmörgås')
++ self.assertEqual(soup.find(string='Räksmörgås'), 'Räksmörgås')
+
+ def test_unicode_attribute_find(self):
+- soup = self.soup(u'here it is')
++ soup = self.soup('here it is')
+ str(soup)
+- self.assertEqual("here it is", soup.find(id=u'Räksmörgås').text)
++ self.assertEqual("here it is", soup.find(id='Räksmörgås').text)
+
+
+ def test_find_everything(self):
+@@ -101,17 +101,17 @@ class TestFindAll(TreeTest):
+ """You can search the tree for text nodes."""
+ soup = self.soup("Foobar\xbb")
+ # Exact match.
+- self.assertEqual(soup.find_all(string="bar"), [u"bar"])
+- self.assertEqual(soup.find_all(text="bar"), [u"bar"])
++ self.assertEqual(soup.find_all(string="bar"), ["bar"])
++ self.assertEqual(soup.find_all(text="bar"), ["bar"])
+ # Match any of a number of strings.
+ self.assertEqual(
+- soup.find_all(text=["Foo", "bar"]), [u"Foo", u"bar"])
++ soup.find_all(text=["Foo", "bar"]), ["Foo", "bar"])
+ # Match a regular expression.
+ self.assertEqual(soup.find_all(text=re.compile('.*')),
+- [u"Foo", u"bar", u'\xbb'])
++ ["Foo", "bar", '\xbb'])
+ # Match anything.
+ self.assertEqual(soup.find_all(text=True),
+- [u"Foo", u"bar", u'\xbb'])
++ ["Foo", "bar", '\xbb'])
+
+ def test_find_all_limit(self):
+ """You can limit the number of items returned by find_all."""
+@@ -254,8 +254,8 @@ class TestFindAllByAttribute(TreeTest):
+ ["Matching a.", "Matching b."])
+
+ def test_find_all_by_utf8_attribute_value(self):
+- peace = u"םולש".encode("utf8")
+- data = u''.encode("utf8")
++ peace = "םולש".encode("utf8")
++ data = ''.encode("utf8")
+ soup = self.soup(data)
+ self.assertEqual([soup.a], soup.find_all(title=peace))
+ self.assertEqual([soup.a], soup.find_all(title=peace.decode("utf8")))
+@@ -444,7 +444,7 @@ class TestSmooth(TreeTest):
+ # output.
+
+ # Since the tag has two children, its .string is None.
+- self.assertEquals(None, div.span.string)
++ self.assertEqual(None, div.span.string)
+
+ self.assertEqual(7, len(div.contents))
+ div.smooth()
+@@ -755,18 +755,18 @@ class TestTag(SoupTest):
+
+ # No list of whitespace-preserving tags -> pretty-print
+ tag._preserve_whitespace_tags = None
+- self.assertEquals(True, tag._should_pretty_print(0))
++ self.assertEqual(True, tag._should_pretty_print(0))
+
+ # List exists but tag is not on the list -> pretty-print
+ tag.preserve_whitespace_tags = ["some_other_tag"]
+- self.assertEquals(True, tag._should_pretty_print(1))
++ self.assertEqual(True, tag._should_pretty_print(1))
+
+ # Indent level is None -> don't pretty-print
+- self.assertEquals(False, tag._should_pretty_print(None))
++ self.assertEqual(False, tag._should_pretty_print(None))
+
+ # Tag is on the whitespace-preserving list -> don't pretty-print
+ tag.preserve_whitespace_tags = ["some_other_tag", "a_tag"]
+- self.assertEquals(False, tag._should_pretty_print(1))
++ self.assertEqual(False, tag._should_pretty_print(1))
+
+
+ class TestTagCreation(SoupTest):
+@@ -905,10 +905,10 @@ class TestTreeModification(SoupTest):
+ assert not isinstance(i, BeautifulSoup)
+
+ p1, p2, p3, p4 = list(soup.children)
+- self.assertEquals("And now, a word:", p1.string)
+- self.assertEquals("p2", p2.string)
+- self.assertEquals("p3", p3.string)
+- self.assertEquals("And we're back.", p4.string)
++ self.assertEqual("And now, a word:", p1.string)
++ self.assertEqual("p2", p2.string)
++ self.assertEqual("p3", p3.string)
++ self.assertEqual("And we're back.", p4.string)
+
+
+ def test_replace_with_maintains_next_element_throughout(self):
+@@ -1015,8 +1015,8 @@ class TestTreeModification(SoupTest):
+ d1 = soup.find('div', id='d1')
+ d2 = soup.find('div', id='d2')
+ d2.extend(d1)
+- self.assertEqual(u'', d1.decode())
+- self.assertEqual(u'', d2.decode())
++ self.assertEqual('', d1.decode())
++ self.assertEqual('', d2.decode())
+
+ def test_move_tag_to_beginning_of_parent(self):
+ data = ""
+@@ -1262,7 +1262,7 @@ class TestTreeModification(SoupTest):
+
+ """)
+ [soup.script.extract() for i in soup.find_all("script")]
+- self.assertEqual("\n\n\n", unicode(soup.body))
++ self.assertEqual("\n\n\n", str(soup.body))
+
+
+ def test_extract_works_when_element_is_surrounded_by_identical_strings(self):
+@@ -1524,7 +1524,7 @@ class TestPersistence(SoupTest):
+ soup = BeautifulSoup(b' ', 'html.parser')
+ encoding = soup.original_encoding
+ copy = soup.__copy__()
+- self.assertEqual(u" ", unicode(copy))
++ self.assertEqual(" ", str(copy))
+ self.assertEqual(encoding, copy.original_encoding)
+
+ def test_copy_preserves_builder_information(self):
+@@ -1554,14 +1554,14 @@ class TestPersistence(SoupTest):
+
+ def test_unicode_pickle(self):
+ # A tree containing Unicode characters can be pickled.
+- html = u"\N{SNOWMAN}"
++ html = "\N{SNOWMAN}"
+ soup = self.soup(html)
+ dumped = pickle.dumps(soup, pickle.HIGHEST_PROTOCOL)
+ loaded = pickle.loads(dumped)
+ self.assertEqual(loaded.decode(), soup.decode())
+
+ def test_copy_navigablestring_is_not_attached_to_tree(self):
+- html = u"FooBar"
++ html = "FooBar"
+ soup = self.soup(html)
+ s1 = soup.find(string="Foo")
+ s2 = copy.copy(s1)
+@@ -1573,7 +1573,7 @@ class TestPersistence(SoupTest):
+ self.assertEqual(None, s2.previous_element)
+
+ def test_copy_navigablestring_subclass_has_same_type(self):
+- html = u""
++ html = ""
+ soup = self.soup(html)
+ s1 = soup.string
+ s2 = copy.copy(s1)
+@@ -1581,19 +1581,19 @@ class TestPersistence(SoupTest):
+ self.assertTrue(isinstance(s2, Comment))
+
+ def test_copy_entire_soup(self):
+- html = u"end"
++ html = "end"
+ soup = self.soup(html)
+ soup_copy = copy.copy(soup)
+ self.assertEqual(soup, soup_copy)
+
+ def test_copy_tag_copies_contents(self):
+- html = u"end"
++ html = "end"
+ soup = self.soup(html)
+ div = soup.div
+ div_copy = copy.copy(div)
+
+ # The two tags look the same, and evaluate to equal.
+- self.assertEqual(unicode(div), unicode(div_copy))
++ self.assertEqual(str(div), str(div_copy))
+ self.assertEqual(div, div_copy)
+
+ # But they're not the same object.
+@@ -1609,17 +1609,17 @@ class TestPersistence(SoupTest):
+ class TestSubstitutions(SoupTest):
+
+ def test_default_formatter_is_minimal(self):
+- markup = u"<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
++ markup = "<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
+ soup = self.soup(markup)
+ decoded = soup.decode(formatter="minimal")
+ # The < is converted back into < but the e-with-acute is left alone.
+ self.assertEqual(
+ decoded,
+ self.document_for(
+- u"<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"))
++ "<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"))
+
+ def test_formatter_html(self):
+- markup = u"
<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
++ markup = "
<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
+ soup = self.soup(markup)
+ decoded = soup.decode(formatter="html")
+ self.assertEqual(
+@@ -1627,7 +1627,7 @@ class TestSubstitutions(SoupTest):
+ self.document_for("
<<Sacré bleu!>>"))
+
+ def test_formatter_html5(self):
+- markup = u"
<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
++ markup = "
<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
+ soup = self.soup(markup)
+ decoded = soup.decode(formatter="html5")
+ self.assertEqual(
+@@ -1635,49 +1635,49 @@ class TestSubstitutions(SoupTest):
+ self.document_for("
<<Sacré bleu!>>"))
+
+ def test_formatter_minimal(self):
+- markup = u"<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
++ markup = "<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
+ soup = self.soup(markup)
+ decoded = soup.decode(formatter="minimal")
+ # The < is converted back into < but the e-with-acute is left alone.
+ self.assertEqual(
+ decoded,
+ self.document_for(
+- u"<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"))
++ "<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"))
+
+ def test_formatter_null(self):
+- markup = u"<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
++ markup = "<<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>>"
+ soup = self.soup(markup)
+ decoded = soup.decode(formatter=None)
+ # Neither the angle brackets nor the e-with-acute are converted.
+ # This is not valid HTML, but it's what the user wanted.
+ self.assertEqual(decoded,
+- self.document_for(u"<>"))
++ self.document_for("<>"))
+
+ def test_formatter_custom(self):
+- markup = u"<foo>bar
"
++ markup = "<foo>bar
"
+ soup = self.soup(markup)
+ decoded = soup.decode(formatter = lambda x: x.upper())
+ # Instead of normal entity conversion code, the custom
+ # callable is called on every string.
+ self.assertEqual(
+ decoded,
+- self.document_for(u"BAR
"))
++ self.document_for("BAR
"))
+
+ def test_formatter_is_run_on_attribute_values(self):
+- markup = u'e'
++ markup = 'e'
+ soup = self.soup(markup)
+ a = soup.a
+
+- expect_minimal = u'e'
++ expect_minimal = 'e'
+
+ self.assertEqual(expect_minimal, a.decode())
+ self.assertEqual(expect_minimal, a.decode(formatter="minimal"))
+
+- expect_html = u'e'
++ expect_html = 'e'
+ self.assertEqual(expect_html, a.decode(formatter="html"))
+
+ self.assertEqual(markup, a.decode(formatter=None))
+- expect_upper = u'E'
++ expect_upper = 'E'
+ self.assertEqual(expect_upper, a.decode(formatter=lambda x: x.upper()))
+
+ def test_formatter_skips_script_tag_for_html_documents(self):
+@@ -1703,7 +1703,7 @@ class TestSubstitutions(SoupTest):
+ # Everything outside the tag is reformatted, but everything
+ # inside is left alone.
+ self.assertEqual(
+- u'\n foo\n \tbar\n \n \n baz\n \n \n foo\n \tbar\n \n \n baz\n \n |