From c6d61e2f60469e0e2c86b0a35c03dad2e53e096c Mon Sep 17 00:00:00 2001
From: stroeder <stroeder>
Date: Mon, 4 Sep 2017 07:47:29 +0000
Subject: [PATCH] avoid deprecated method alias unittest.TestCase.assertEquals

---
 CHANGES                   |   3 +-
 Tests/t_cext.py           | 218 +++++++++++++++++++-------------------
 Tests/t_cidict.py         |  22 ++--
 Tests/t_ldap_dn.py        |  16 +--
 Tests/t_ldap_filter.py    |  12 +--
 Tests/t_ldap_functions.py |  18 ++--
 Tests/t_ldapobject.py     |   8 +-
 Tests/t_ldapurl.py        | 154 +++++++++++++--------------
 8 files changed, 226 insertions(+), 225 deletions(-)

diff --git a/CHANGES b/CHANGES
index c59e69d..0cb3cf0 100644
--- a/CHANGES
+++ b/CHANGES
@@ -12,6 +12,7 @@ Lib/
 
 Tests/
 * added sub-module for testing class ldap.cidict.cidict
+* avoid deprecated method alias unittest.TestCase.assertEquals
 
 ----------------------------------------------------------------
 Released 2.4.41 2017-07-12
@@ -1475,4 +1476,4 @@ Released 2.0.0pre02 2002-02-01
 ----------------------------------------------------------------
 Released 1.10alpha3 2000-09-19
 
-$Id: CHANGES,v 1.456 2017/08/16 13:29:05 stroeder Exp $
+$Id: CHANGES,v 1.457 2017/09/04 07:47:29 stroeder Exp $
diff --git a/Tests/t_cext.py b/Tests/t_cext.py
index edb4adb..6ced288 100644
--- a/Tests/t_cext.py
+++ b/Tests/t_cext.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_cext.py,v 1.23 2017/08/15 16:21:59 stroeder Exp $
+$Id: t_cext.py,v 1.24 2017/09/04 07:47:29 stroeder Exp $
 """
 
 import os
@@ -77,23 +77,23 @@ def test_constants(self):
         """
         Test whether all libldap-derived constants are correct
         """
-        self.assertEquals(_ldap.PORT, 389)
-        self.assertEquals(_ldap.VERSION1, 1)
-        self.assertEquals(_ldap.VERSION2, 2)
-        self.assertEquals(_ldap.VERSION3, 3)
+        self.assertEqual(_ldap.PORT, 389)
+        self.assertEqual(_ldap.VERSION1, 1)
+        self.assertEqual(_ldap.VERSION2, 2)
+        self.assertEqual(_ldap.VERSION3, 3)
 
         # constants for result4()
-        self.assertEquals(_ldap.RES_BIND, 0x61)
-        self.assertEquals(_ldap.RES_SEARCH_ENTRY, 0x64)
-        self.assertEquals(_ldap.RES_SEARCH_RESULT, 0x65)
-        self.assertEquals(_ldap.RES_MODIFY, 0x67)
-        self.assertEquals(_ldap.RES_ADD, 0x69)
-        self.assertEquals(_ldap.RES_DELETE, 0x6b)
-        self.assertEquals(_ldap.RES_MODRDN, 0x6d)
-        self.assertEquals(_ldap.RES_COMPARE, 0x6f)
-        self.assertEquals(_ldap.RES_SEARCH_REFERENCE, 0x73) # v3
-        self.assertEquals(_ldap.RES_EXTENDED, 0x78)         # v3
-        #self.assertEquals(_ldap.RES_INTERMEDIATE, 0x79)     # v3
+        self.assertEqual(_ldap.RES_BIND, 0x61)
+        self.assertEqual(_ldap.RES_SEARCH_ENTRY, 0x64)
+        self.assertEqual(_ldap.RES_SEARCH_RESULT, 0x65)
+        self.assertEqual(_ldap.RES_MODIFY, 0x67)
+        self.assertEqual(_ldap.RES_ADD, 0x69)
+        self.assertEqual(_ldap.RES_DELETE, 0x6b)
+        self.assertEqual(_ldap.RES_MODRDN, 0x6d)
+        self.assertEqual(_ldap.RES_COMPARE, 0x6f)
+        self.assertEqual(_ldap.RES_SEARCH_REFERENCE, 0x73) # v3
+        self.assertEqual(_ldap.RES_EXTENDED, 0x78)         # v3
+        #self.assertEqual(_ldap.RES_INTERMEDIATE, 0x79)     # v3
         self.assertNotNone(_ldap.RES_ANY)
         self.assertNotNone(_ldap.RES_UNSOLICITED)
 
@@ -170,8 +170,8 @@ def test_constants(self):
         self.assertNotNone(_ldap.AVA_NONPRINTABLE)
 
         # these two constants are pointless? XXX
-        self.assertEquals(_ldap.OPT_ON, 1)
-        self.assertEquals(_ldap.OPT_OFF, 0)
+        self.assertEqual(_ldap.OPT_ON, 1)
+        self.assertEqual(_ldap.OPT_OFF, 0)
 
         # these constants useless after ldap_url_parse() was dropped XXX
         self.assertNotNone(_ldap.URL_ERR_BADSCOPE)
@@ -186,9 +186,9 @@ def test_simple_anonymous_bind(self):
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
         self.assertTrue(result, _ldap.RES_BIND)
-        self.assertEquals(msgid, m)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(ctrls, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(ctrls, [])
 
     def test_anon_rootdse_search(self):
         l = self._open_conn(bind=False)
@@ -201,15 +201,15 @@ def test_anon_rootdse_search(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(pmsg[0][0], "") # rootDSE has no dn
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(pmsg[0][0], "") # rootDSE has no dn
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
         root_dse = pmsg[0][1]
         self.assertTrue('objectClass' in root_dse)
         self.assertTrue('OpenLDAProotDSE' in root_dse['objectClass'])
         self.assertTrue('namingContexts' in root_dse)
-        self.assertEquals(root_dse['namingContexts'], [self.server.suffix])
+        self.assertEqual(root_dse['namingContexts'], [self.server.suffix])
 
     def test_unbind(self):
         l = self._open_conn()
@@ -232,21 +232,21 @@ def test_search_ext_individual(self):
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ONE, self.timeout)
         # Expect to get just one object
-        self.assertEquals(result, _ldap.RES_SEARCH_ENTRY)
-        self.assertEquals(len(pmsg), 1)
-        self.assertEquals(len(pmsg[0]), 2)
-        self.assertEquals(pmsg[0][0], self.server.suffix)
-        self.assertEquals(pmsg[0][0], self.server.suffix)
+        self.assertEqual(result, _ldap.RES_SEARCH_ENTRY)
+        self.assertEqual(len(pmsg), 1)
+        self.assertEqual(len(pmsg[0]), 2)
+        self.assertEqual(pmsg[0][0], self.server.suffix)
+        self.assertEqual(pmsg[0][0], self.server.suffix)
         self.assertTrue('dcObject' in pmsg[0][1]['objectClass'])
         self.assertTrue('organization' in pmsg[0][1]['objectClass'])
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
 
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ONE, self.timeout)
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
 
     def test_abandon(self):
         l = self._open_conn()
@@ -267,10 +267,10 @@ def test_search_ext_all(self):
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
         # Expect to get some objects
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
         self.assertTrue(len(pmsg) >= 2)
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
 
     def test_add(self):
         """
@@ -287,19 +287,19 @@ def test_add(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_ADD)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
         # search for it back
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(cn=Foo)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
         # Expect to get the objects
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(len(pmsg), 1)
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
-        self.assertEquals(
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(len(pmsg), 1)
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
+        self.assertEqual(
             pmsg[0],
             (
                 'cn=Foo,'+self.server.suffix,
@@ -329,7 +329,7 @@ def test_compare(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
         # try a false compare
         m = l.compare_ext(dn, "userPassword", "bad_string")
         try:
@@ -381,14 +381,14 @@ def test_delete(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
 
         m = l.delete_ext(dn)
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_DELETE)
-        self.assertEquals(msgid, m)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_DELETE)
+        self.assertEqual(msgid, m)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(ctrls, [])
 
     def test_modify_no_such_object(self):
         l = self._open_conn()
@@ -444,7 +444,7 @@ def test_modify(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
 
         m = l.modify_ext(
             dn,
@@ -453,22 +453,22 @@ def test_modify(self):
             ]
         )
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_MODIFY)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_MODIFY)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
         # search for it back
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(cn=AddToMe)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
         # Expect to get the objects
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(len(pmsg), 1)
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
-        self.assertEquals(pmsg[0][0], dn)
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(len(pmsg), 1)
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
+        self.assertEqual(pmsg[0][0], dn)
         d = list(pmsg[0][1]['description'])
         d.sort()
-        self.assertEquals(d, ['a description', 'b desc', 'c desc'])
+        self.assertEqual(d, ['a description', 'b desc', 'c desc'])
 
     def test_rename(self):
         l = self._open_conn()
@@ -482,34 +482,34 @@ def test_rename(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
 
         # do the rename with same parent
         m = l.rename(dn, "cn=IAmRenamed")
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_MODRDN)
-        self.assertEquals(msgid, m)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_MODRDN)
+        self.assertEqual(msgid, m)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(ctrls, [])
 
         # make sure the old one is gone
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(cn=RenameMe)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(len(pmsg), 0) # expect no results
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(len(pmsg), 0) # expect no results
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
 
         # check that the new one looks right
         dn2 = "cn=IAmRenamed,"+self.server.suffix
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(cn=IAmRenamed)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
-        self.assertEquals(len(pmsg), 1)
-        self.assertEquals(pmsg[0][0], dn2)
-        self.assertEquals(pmsg[0][1]['cn'], ['IAmRenamed'])
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
+        self.assertEqual(len(pmsg), 1)
+        self.assertEqual(pmsg[0][0], dn2)
+        self.assertEqual(pmsg[0][1]['cn'], ['IAmRenamed'])
 
         # create the container
         containerDn = "ou=RenameContainer,"+self.server.suffix
@@ -521,7 +521,7 @@ def test_rename(self):
             ]
         )
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
 
         # WORKAROUND bug in slapd. (Without an existing child,
         # renames into a container object do not work for the ldif backend,
@@ -535,7 +535,7 @@ def test_rename(self):
             ]
         )
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
 
         # now rename from dn2 to the conater
         dn3 = "cn=IAmRenamedAgain," + containerDn
@@ -543,18 +543,18 @@ def test_rename(self):
         # Now try renaming dn2 across container (simultaneous name change)
         m = l.rename(dn2, "cn=IAmRenamedAgain", containerDn)
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_MODRDN)
-        self.assertEquals(msgid, m)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_MODRDN)
+        self.assertEqual(msgid, m)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(ctrls, [])
 
         # make sure dn2 is gone
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(cn=IAmRenamed)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(len(pmsg), 0) # expect no results
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(len(pmsg), 0) # expect no results
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
 
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(objectClass=*)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
@@ -562,24 +562,24 @@ def test_rename(self):
         # make sure dn3 is there
         m = l.search_ext(self.server.suffix, _ldap.SCOPE_SUBTREE, '(cn=IAmRenamedAgain)')
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_SEARCH_RESULT)
-        self.assertEquals(msgid, m)
-        self.assertEquals(ctrls, [])
-        self.assertEquals(len(pmsg), 1)
-        self.assertEquals(pmsg[0][0], dn3)
-        self.assertEquals(pmsg[0][1]['cn'], ['IAmRenamedAgain'])
+        self.assertEqual(result, _ldap.RES_SEARCH_RESULT)
+        self.assertEqual(msgid, m)
+        self.assertEqual(ctrls, [])
+        self.assertEqual(len(pmsg), 1)
+        self.assertEqual(pmsg[0][0], dn3)
+        self.assertEqual(pmsg[0][1]['cn'], ['IAmRenamedAgain'])
 
 
     def test_whoami(self):
         l = self._open_conn()
         r = l.whoami_s()
-        self.assertEquals("dn:" + self.server.root_dn, r)
+        self.assertEqual("dn:" + self.server.root_dn, r)
 
     def test_whoami_unbound(self):
         l = self._open_conn(bind=False)
         l.set_option(_ldap.OPT_PROTOCOL_VERSION, _ldap.VERSION3)
         r = l.whoami_s()
-        self.assertEquals("", r)
+        self.assertEqual("", r)
 
     def test_whoami_anonymous(self):
         l = self._open_conn(bind=False)
@@ -590,7 +590,7 @@ def test_whoami_anonymous(self):
         self.assertTrue(result, _ldap.RES_BIND)
         # check with Who Am I? extended operation
         r = l.whoami_s()
-        self.assertEquals("", r)
+        self.assertEqual("", r)
 
     def test_passwd(self):
         l = self._open_conn()
@@ -607,7 +607,7 @@ def test_passwd(self):
         )
         self.assertEqual(type(m), type(0))
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(result, _ldap.RES_ADD)
+        self.assertEqual(result, _ldap.RES_ADD)
         # try changing password with a wrong old-pw
         m = l.passwd(dn, "bogus", "ignored")
         self.assertEqual(type(m), type(0))
@@ -620,10 +620,10 @@ def test_passwd(self):
         # try changing password with a correct old-pw
         m = l.passwd(dn, "initial", "changed")
         result, pmsg, msgid, ctrls = l.result4(m, _ldap.MSG_ALL, self.timeout)
-        self.assertEquals(msgid, m)
-        self.assertEquals(pmsg, [])
-        self.assertEquals(result, _ldap.RES_EXTENDED)
-        self.assertEquals(ctrls, [])
+        self.assertEqual(msgid, m)
+        self.assertEqual(pmsg, [])
+        self.assertEqual(result, _ldap.RES_EXTENDED)
+        self.assertEqual(ctrls, [])
 
     def test_options(self):
         oldval = _ldap.get_option(_ldap.OPT_PROTOCOL_VERSION)
@@ -638,10 +638,10 @@ def test_options(self):
 
             _ldap.set_option(_ldap.OPT_PROTOCOL_VERSION, _ldap.VERSION2)
             v = _ldap.get_option(_ldap.OPT_PROTOCOL_VERSION)
-            self.assertEquals(v, _ldap.VERSION2)
+            self.assertEqual(v, _ldap.VERSION2)
             _ldap.set_option(_ldap.OPT_PROTOCOL_VERSION, _ldap.VERSION3)
             v = _ldap.get_option(_ldap.OPT_PROTOCOL_VERSION)
-            self.assertEquals(v, _ldap.VERSION3)
+            self.assertEqual(v, _ldap.VERSION3)
         finally:
             _ldap.set_option(_ldap.OPT_PROTOCOL_VERSION, oldval)
 
@@ -651,11 +651,11 @@ def test_options(self):
 
         l.set_option(_ldap.OPT_PROTOCOL_VERSION, _ldap.VERSION2)
         v = l.get_option(_ldap.OPT_PROTOCOL_VERSION)
-        self.assertEquals(v, _ldap.VERSION2)
+        self.assertEqual(v, _ldap.VERSION2)
 
         l.set_option(_ldap.OPT_PROTOCOL_VERSION, _ldap.VERSION3)
         v = l.get_option(_ldap.OPT_PROTOCOL_VERSION)
-        self.assertEquals(v, _ldap.VERSION3)
+        self.assertEqual(v, _ldap.VERSION3)
 
         # Try setting options that will yield a known error.
         try:
diff --git a/Tests/t_cidict.py b/Tests/t_cidict.py
index 8915ceb..ab79b28 100644
--- a/Tests/t_cidict.py
+++ b/Tests/t_cidict.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_cidict.py,v 1.2 2017/08/15 16:14:04 stroeder Exp $
+$Id: t_cidict.py,v 1.3 2017/09/04 07:47:29 stroeder Exp $
 """
 
 # from Python's standard lib
@@ -23,26 +23,26 @@ def test_cidict(self):
         """
         test function is_dn()
         """
-        self.assertEquals(ldap.dn.is_dn('foobar,ou=ae-dir'), False)
+        self.assertEqual(ldap.dn.is_dn('foobar,ou=ae-dir'), False)
         data = {
             'AbCDeF':123,
         }
         cix = ldap.cidict.cidict(data)
-        self.assertEquals(cix["ABCDEF"], 123)
-        self.assertEquals(cix.get("ABCDEF", None), 123)
-        self.assertEquals(cix.get("not existent", None), None)
+        self.assertEqual(cix["ABCDEF"], 123)
+        self.assertEqual(cix.get("ABCDEF", None), 123)
+        self.assertEqual(cix.get("not existent", None), None)
         cix["xYZ"] = 987
-        self.assertEquals(cix["XyZ"], 987)
-        self.assertEquals(cix.get("xyz", None), 987)
+        self.assertEqual(cix["XyZ"], 987)
+        self.assertEqual(cix.get("xyz", None), 987)
         cix_keys = cix.keys()
         cix_keys.sort()
-        self.assertEquals(cix_keys, ['AbCDeF','xYZ'])
+        self.assertEqual(cix_keys, ['AbCDeF','xYZ'])
         cix_items = cix.items()
         cix_items.sort()
-        self.assertEquals(cix_items, [('AbCDeF',123), ('xYZ',987)])
+        self.assertEqual(cix_items, [('AbCDeF',123), ('xYZ',987)])
         del cix["abcdEF"]
-        self.assertEquals(cix._keys.has_key("abcdef"), False)
-        self.assertEquals(cix._keys.has_key("AbCDef"), False)
+        self.assertEqual(cix._keys.has_key("abcdef"), False)
+        self.assertEqual(cix._keys.has_key("AbCDef"), False)
 
 
 if __name__ == '__main__':
diff --git a/Tests/t_ldap_dn.py b/Tests/t_ldap_dn.py
index 4a3f773..1507d2e 100644
--- a/Tests/t_ldap_dn.py
+++ b/Tests/t_ldap_dn.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_ldap_dn.py,v 1.5 2017/08/15 16:21:59 stroeder Exp $
+$Id: t_ldap_dn.py,v 1.6 2017/09/04 07:47:29 stroeder Exp $
 """
 
 # from Python's standard lib
@@ -23,13 +23,13 @@ def test_is_dn(self):
         """
         test function is_dn()
         """
-        self.assertEquals(ldap.dn.is_dn('foobar,ou=ae-dir'), False)
-        self.assertEquals(ldap.dn.is_dn('-cn=foobar,ou=ae-dir'), False)
-        self.assertEquals(ldap.dn.is_dn(';cn=foobar,ou=ae-dir'), False)
-        self.assertEquals(ldap.dn.is_dn(',cn=foobar,ou=ae-dir'), False)
-        self.assertEquals(ldap.dn.is_dn('cn=foobar,ou=ae-dir,'), False)
-        self.assertEquals(ldap.dn.is_dn('uid=xkcd,cn=foobar,ou=ae-dir'), True)
-        self.assertEquals(
+        self.assertEqual(ldap.dn.is_dn('foobar,ou=ae-dir'), False)
+        self.assertEqual(ldap.dn.is_dn('-cn=foobar,ou=ae-dir'), False)
+        self.assertEqual(ldap.dn.is_dn(';cn=foobar,ou=ae-dir'), False)
+        self.assertEqual(ldap.dn.is_dn(',cn=foobar,ou=ae-dir'), False)
+        self.assertEqual(ldap.dn.is_dn('cn=foobar,ou=ae-dir,'), False)
+        self.assertEqual(ldap.dn.is_dn('uid=xkcd,cn=foobar,ou=ae-dir'), True)
+        self.assertEqual(
             ldap.dn.is_dn(
                 'cn=\xc3\xa4\xc3\xb6\xc3\xbc\xc3\x84\xc3\x96\xc3\x9c.o=\xc3\xa4\xc3\xb6\xc3\xbc\xc3\x84\xc3\x96\xc3\x9c\xc3\x9f'
             ),
diff --git a/Tests/t_ldap_filter.py b/Tests/t_ldap_filter.py
index b5a38d9..f50a217 100644
--- a/Tests/t_ldap_filter.py
+++ b/Tests/t_ldap_filter.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_ldap_filter.py,v 1.4 2017/08/15 16:21:59 stroeder Exp $
+$Id: t_ldap_filter.py,v 1.5 2017/09/04 07:47:29 stroeder Exp $
 """
 
 # from Python's standard lib
@@ -23,15 +23,15 @@ def test_escape_filter_chars_mode0(self):
         """
         test function escape_filter_chars() with escape_mode=0
         """
-        self.assertEquals(
+        self.assertEqual(
             escape_filter_chars(r'foobar'),
             'foobar'
         )
-        self.assertEquals(
+        self.assertEqual(
             escape_filter_chars(r'foo\bar'),
             r'foo\5cbar'
         )
-        self.assertEquals(
+        self.assertEqual(
             escape_filter_chars(
                 r'foo\bar',
                 escape_mode=0
@@ -43,7 +43,7 @@ def test_escape_filter_chars_mode1(self):
         """
         test function escape_filter_chars() with escape_mode=1
         """
-        self.assertEquals(
+        self.assertEqual(
             escape_filter_chars(
                 '\xc3\xa4\xc3\xb6\xc3\xbc\xc3\x84\xc3\x96\xc3\x9c\xc3\x9f',
                 escape_mode=1
@@ -55,7 +55,7 @@ def test_escape_filter_chars_mode2(self):
         """
         test function escape_filter_chars() with escape_mode=2
         """
-        self.assertEquals(
+        self.assertEqual(
             escape_filter_chars(
                 'foobar',
                 escape_mode=2
diff --git a/Tests/t_ldap_functions.py b/Tests/t_ldap_functions.py
index 4416d57..1928c67 100644
--- a/Tests/t_ldap_functions.py
+++ b/Tests/t_ldap_functions.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_ldap_functions.py,v 1.3 2017/08/15 16:21:59 stroeder Exp $
+$Id: t_ldap_functions.py,v 1.4 2017/09/04 07:47:29 stroeder Exp $
 """
 
 # from Python's standard lib
@@ -25,21 +25,21 @@ def test_ldap_strf_secs(self):
         """
         test function ldap_strf_secs()
         """
-        self.assertEquals(ldap.strf_secs(0), '19700101000000Z')
-        self.assertEquals(ldap.strf_secs(1466947067), '20160626131747Z')
+        self.assertEqual(ldap.strf_secs(0), '19700101000000Z')
+        self.assertEqual(ldap.strf_secs(1466947067), '20160626131747Z')
 
     def test_ldap_strp_secs(self):
         """
         test function ldap_strp_secs()
         """
-        self.assertEquals(ldap.strp_secs('19700101000000Z'), 0)
-        self.assertEquals(ldap.strp_secs('20160626131747Z'), 1466947067)
+        self.assertEqual(ldap.strp_secs('19700101000000Z'), 0)
+        self.assertEqual(ldap.strp_secs('20160626131747Z'), 1466947067)
 
     def test_escape_str(self):
         """
         test function escape_string_tmpl()
         """
-        self.assertEquals(
+        self.assertEqual(
             ldap.escape_str(
                 escape_filter_chars,
                 '(&(objectClass=aeUser)(uid=%s))',
@@ -47,7 +47,7 @@ def test_escape_str(self):
             ),
             '(&(objectClass=aeUser)(uid=foo))'
         )
-        self.assertEquals(
+        self.assertEqual(
             ldap.escape_str(
                 escape_filter_chars,
                 '(&(objectClass=aeUser)(uid=%s))',
@@ -55,7 +55,7 @@ def test_escape_str(self):
             ),
             '(&(objectClass=aeUser)(uid=foo\\29bar))'
         )
-        self.assertEquals(
+        self.assertEqual(
             ldap.escape_str(
                 escape_dn_chars,
                 'uid=%s',
@@ -63,7 +63,7 @@ def test_escape_str(self):
             ),
             'uid=foo\\=bar'
         )
-        self.assertEquals(
+        self.assertEqual(
             ldap.escape_str(
                 escape_dn_chars,
                 'uid=%s,cn=%s,cn=%s,dc=example,dc=com',
diff --git a/Tests/t_ldapobject.py b/Tests/t_ldapobject.py
index 8f67bec..e9df53c 100644
--- a/Tests/t_ldapobject.py
+++ b/Tests/t_ldapobject.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_ldapobject.py,v 1.8 2017/08/15 16:21:59 stroeder Exp $
+$Id: t_ldapobject.py,v 1.9 2017/09/04 07:47:29 stroeder Exp $
 """
 
 import os
@@ -88,7 +88,7 @@ def test_search_subtree(self):
             attrlist=['*'],
         )
         result.sort()
-        self.assertEquals(
+        self.assertEqual(
             result,
             [
                 (
@@ -118,7 +118,7 @@ def test_search_onelevel(self):
             ['*'],
         )
         result.sort()
-        self.assertEquals(
+        self.assertEqual(
             result,
             [
                 (
@@ -144,7 +144,7 @@ def test_search_oneattr(self):
             ['cn'],
         )
         result.sort()
-        self.assertEquals(
+        self.assertEqual(
             result,
             [('cn=Foo4,ou=Container,'+self.server.suffix, {'cn': ['Foo4']})]
         )
diff --git a/Tests/t_ldapurl.py b/Tests/t_ldapurl.py
index 1b0758e..161e99c 100644
--- a/Tests/t_ldapurl.py
+++ b/Tests/t_ldapurl.py
@@ -4,7 +4,7 @@
 
 See https://www.python-ldap.org/ for details.
 
-$Id: t_ldapurl.py,v 1.13 2017/08/15 16:21:59 stroeder Exp $
+$Id: t_ldapurl.py,v 1.14 2017/09/04 07:47:29 stroeder Exp $
 """
 
 import unittest
@@ -192,29 +192,29 @@ def test_combo(self):
             + ",X-BINDPW=" + urllib.quote("???")
             + ",trace=8"
         )
-        self.assertEquals(u.urlscheme, "ldap")
-        self.assertEquals(u.hostport, "127.0.0.1:1234")
-        self.assertEquals(u.dn, "dc=example,dc=com")
-        self.assertEquals(u.attrs, ["attr1","attr2","attr3"])
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_SUBTREE)
-        self.assertEquals(u.filterstr, "(objectClass=*)")
-        self.assertEquals(len(u.extensions), 3)
-        self.assertEquals(u.who, "cn=d,c=au")
-        self.assertEquals(u.cred, "???")
-        self.assertEquals(u.trace_level, "8")
+        self.assertEqual(u.urlscheme, "ldap")
+        self.assertEqual(u.hostport, "127.0.0.1:1234")
+        self.assertEqual(u.dn, "dc=example,dc=com")
+        self.assertEqual(u.attrs, ["attr1","attr2","attr3"])
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_SUBTREE)
+        self.assertEqual(u.filterstr, "(objectClass=*)")
+        self.assertEqual(len(u.extensions), 3)
+        self.assertEqual(u.who, "cn=d,c=au")
+        self.assertEqual(u.cred, "???")
+        self.assertEqual(u.trace_level, "8")
 
     def test_parse_default_hostport(self):
         u = LDAPUrl("ldap://")
-        self.assertEquals(u.urlscheme, "ldap")
-        self.assertEquals(u.hostport, "")
+        self.assertEqual(u.urlscheme, "ldap")
+        self.assertEqual(u.hostport, "")
 
     def test_parse_empty_dn(self):
         u = LDAPUrl("ldap://")
-        self.assertEquals(u.dn, "")
+        self.assertEqual(u.dn, "")
         u = LDAPUrl("ldap:///")
-        self.assertEquals(u.dn, "")
+        self.assertEqual(u.dn, "")
         u = LDAPUrl("ldap:///?")
-        self.assertEquals(u.dn, "")
+        self.assertEqual(u.dn, "")
 
     def test_parse_default_attrs(self):
         u = LDAPUrl("ldap://")
@@ -230,71 +230,71 @@ def test_parse_default_filter(self):
 
     def test_parse_default_extensions(self):
         u = LDAPUrl("ldap://")
-        self.assertEquals(len(u.extensions), 0)
+        self.assertEqual(len(u.extensions), 0)
 
     def test_parse_schemes(self):
         u = LDAPUrl("ldap://")
-        self.assertEquals(u.urlscheme, "ldap")
+        self.assertEqual(u.urlscheme, "ldap")
         u = LDAPUrl("ldapi://")
-        self.assertEquals(u.urlscheme, "ldapi")
+        self.assertEqual(u.urlscheme, "ldapi")
         u = LDAPUrl("ldaps://")
-        self.assertEquals(u.urlscheme, "ldaps")
+        self.assertEqual(u.urlscheme, "ldaps")
 
     def test_parse_hostport(self):
         u = LDAPUrl("ldap://a")
-        self.assertEquals(u.hostport, "a")
+        self.assertEqual(u.hostport, "a")
         u = LDAPUrl("ldap://a.b")
-        self.assertEquals(u.hostport, "a.b")
+        self.assertEqual(u.hostport, "a.b")
         u = LDAPUrl("ldap://a.")
-        self.assertEquals(u.hostport, "a.")
+        self.assertEqual(u.hostport, "a.")
         u = LDAPUrl("ldap://%61%62:%32/")
-        self.assertEquals(u.hostport, "ab:2")
+        self.assertEqual(u.hostport, "ab:2")
         u = LDAPUrl("ldap://[::1]/")
-        self.assertEquals(u.hostport, "[::1]")
+        self.assertEqual(u.hostport, "[::1]")
         u = LDAPUrl("ldap://[::1]")
-        self.assertEquals(u.hostport, "[::1]")
+        self.assertEqual(u.hostport, "[::1]")
         u = LDAPUrl("ldap://[::1]:123/")
-        self.assertEquals(u.hostport, "[::1]:123")
+        self.assertEqual(u.hostport, "[::1]:123")
         u = LDAPUrl("ldap://[::1]:123")
-        self.assertEquals(u.hostport, "[::1]:123")
+        self.assertEqual(u.hostport, "[::1]:123")
 
     def test_parse_dn(self):
         u = LDAPUrl("ldap:///")
-        self.assertEquals(u.dn, "")
+        self.assertEqual(u.dn, "")
         u = LDAPUrl("ldap:///dn=foo")
-        self.assertEquals(u.dn, "dn=foo")
+        self.assertEqual(u.dn, "dn=foo")
         u = LDAPUrl("ldap:///dn=foo%2cdc=bar")
-        self.assertEquals(u.dn, "dn=foo,dc=bar")
+        self.assertEqual(u.dn, "dn=foo,dc=bar")
         u = LDAPUrl("ldap:///dn=foo%20bar")
-        self.assertEquals(u.dn, "dn=foo bar")
+        self.assertEqual(u.dn, "dn=foo bar")
         u = LDAPUrl("ldap:///dn=foo%2fbar")
-        self.assertEquals(u.dn, "dn=foo/bar")
+        self.assertEqual(u.dn, "dn=foo/bar")
         u = LDAPUrl("ldap:///dn=foo%2fbar?")
-        self.assertEquals(u.dn, "dn=foo/bar")
+        self.assertEqual(u.dn, "dn=foo/bar")
         u = LDAPUrl("ldap:///dn=foo%3f?")
-        self.assertEquals(u.dn, "dn=foo?")
+        self.assertEqual(u.dn, "dn=foo?")
         u = LDAPUrl("ldap:///dn=foo%3f")
-        self.assertEquals(u.dn, "dn=foo?")
+        self.assertEqual(u.dn, "dn=foo?")
         u = LDAPUrl("ldap:///dn=str%c3%b6der.com")
-        self.assertEquals(u.dn, "dn=str\xc3\xb6der.com")
+        self.assertEqual(u.dn, "dn=str\xc3\xb6der.com")
 
     def test_parse_attrs(self):
         u = LDAPUrl("ldap:///?")
-        self.assertEquals(u.attrs, None)
+        self.assertEqual(u.attrs, None)
         u = LDAPUrl("ldap:///??")
-        self.assertEquals(u.attrs, None)
+        self.assertEqual(u.attrs, None)
         u = LDAPUrl("ldap:///?*?")
-        self.assertEquals(u.attrs, ['*'])
+        self.assertEqual(u.attrs, ['*'])
         u = LDAPUrl("ldap:///?*,*?")
-        self.assertEquals(u.attrs, ['*','*'])
+        self.assertEqual(u.attrs, ['*','*'])
         u = LDAPUrl("ldap:///?a")
-        self.assertEquals(u.attrs, ['a'])
+        self.assertEqual(u.attrs, ['a'])
         u = LDAPUrl("ldap:///?%61")
-        self.assertEquals(u.attrs, ['a'])
+        self.assertEqual(u.attrs, ['a'])
         u = LDAPUrl("ldap:///?a,b")
-        self.assertEquals(u.attrs, ['a','b'])
+        self.assertEqual(u.attrs, ['a','b'])
         u = LDAPUrl("ldap:///?a%3fb")
-        self.assertEquals(u.attrs, ['a?b'])
+        self.assertEqual(u.attrs, ['a?b'])
 
     def test_parse_scope_default(self):
         u = LDAPUrl("ldap:///??")
@@ -304,77 +304,77 @@ def test_parse_scope_default(self):
 
     def test_parse_scope(self):
         u = LDAPUrl("ldap:///??sub")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_SUBTREE)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_SUBTREE)
         u = LDAPUrl("ldap:///??sub?")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_SUBTREE)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_SUBTREE)
         u = LDAPUrl("ldap:///??base")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_BASE)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_BASE)
         u = LDAPUrl("ldap:///??base?")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_BASE)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_BASE)
         u = LDAPUrl("ldap:///??one")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_ONELEVEL)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_ONELEVEL)
         u = LDAPUrl("ldap:///??one?")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_ONELEVEL)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_ONELEVEL)
         u = LDAPUrl("ldap:///??subordinates")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_SUBORDINATES)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_SUBORDINATES)
         u = LDAPUrl("ldap:///??subordinates?")
-        self.assertEquals(u.scope, ldapurl.LDAP_SCOPE_SUBORDINATES)
+        self.assertEqual(u.scope, ldapurl.LDAP_SCOPE_SUBORDINATES)
 
     def test_parse_filter(self):
         u = LDAPUrl("ldap:///???(cn=Bob)")
-        self.assertEquals(u.filterstr, "(cn=Bob)")
+        self.assertEqual(u.filterstr, "(cn=Bob)")
         u = LDAPUrl("ldap:///???(cn=Bob)?")
-        self.assertEquals(u.filterstr, "(cn=Bob)")
+        self.assertEqual(u.filterstr, "(cn=Bob)")
         u = LDAPUrl("ldap:///???(cn=Bob%20Smith)?")
-        self.assertEquals(u.filterstr, "(cn=Bob Smith)")
+        self.assertEqual(u.filterstr, "(cn=Bob Smith)")
         u = LDAPUrl("ldap:///???(cn=Bob/Smith)?")
-        self.assertEquals(u.filterstr, "(cn=Bob/Smith)")
+        self.assertEqual(u.filterstr, "(cn=Bob/Smith)")
         u = LDAPUrl("ldap:///???(cn=Bob:Smith)?")
-        self.assertEquals(u.filterstr, "(cn=Bob:Smith)")
+        self.assertEqual(u.filterstr, "(cn=Bob:Smith)")
         u = LDAPUrl("ldap:///???&(cn=Bob)(objectClass=user)?")
-        self.assertEquals(u.filterstr, "&(cn=Bob)(objectClass=user)")
+        self.assertEqual(u.filterstr, "&(cn=Bob)(objectClass=user)")
         u = LDAPUrl("ldap:///???|(cn=Bob)(objectClass=user)?")
-        self.assertEquals(u.filterstr, "|(cn=Bob)(objectClass=user)")
+        self.assertEqual(u.filterstr, "|(cn=Bob)(objectClass=user)")
         u = LDAPUrl("ldap:///???(cn=Q%3f)?")
-        self.assertEquals(u.filterstr, "(cn=Q?)")
+        self.assertEqual(u.filterstr, "(cn=Q?)")
         u = LDAPUrl("ldap:///???(cn=Q%3f)")
-        self.assertEquals(u.filterstr, "(cn=Q?)")
+        self.assertEqual(u.filterstr, "(cn=Q?)")
         u = LDAPUrl("ldap:///???(sn=Str%c3%b6der)") # (possibly bad?)
-        self.assertEquals(u.filterstr, "(sn=Str\xc3\xb6der)")
+        self.assertEqual(u.filterstr, "(sn=Str\xc3\xb6der)")
         u = LDAPUrl("ldap:///???(sn=Str\\c3\\b6der)")
-        self.assertEquals(u.filterstr, "(sn=Str\\c3\\b6der)") # (recommended)
+        self.assertEqual(u.filterstr, "(sn=Str\\c3\\b6der)") # (recommended)
         u = LDAPUrl("ldap:///???(cn=*\\2a*)")
-        self.assertEquals(u.filterstr, "(cn=*\\2a*)")
+        self.assertEqual(u.filterstr, "(cn=*\\2a*)")
         u = LDAPUrl("ldap:///???(cn=*%5c2a*)")
-        self.assertEquals(u.filterstr, "(cn=*\\2a*)")
+        self.assertEqual(u.filterstr, "(cn=*\\2a*)")
 
     def test_parse_extensions(self):
         u = LDAPUrl("ldap:///????")
         self.assertNone(u.extensions)
         self.assertNone(u.who)
         u = LDAPUrl("ldap:///????bindname=cn=root")
-        self.assertEquals(len(u.extensions), 1)
-        self.assertEquals(u.who, "cn=root")
+        self.assertEqual(len(u.extensions), 1)
+        self.assertEqual(u.who, "cn=root")
         u = LDAPUrl("ldap:///????!bindname=cn=root")
-        self.assertEquals(len(u.extensions), 1)
-        self.assertEquals(u.who, "cn=root")
+        self.assertEqual(len(u.extensions), 1)
+        self.assertEqual(u.who, "cn=root")
         u = LDAPUrl("ldap:///????bindname=%3f,X-BINDPW=%2c")
-        self.assertEquals(len(u.extensions), 2)
-        self.assertEquals(u.who, "?")
-        self.assertEquals(u.cred, ",")
+        self.assertEqual(len(u.extensions), 2)
+        self.assertEqual(u.who, "?")
+        self.assertEqual(u.cred, ",")
 
     def test_parse_extensions_nulls(self):
         u = LDAPUrl("ldap:///????bindname=%00name")
-        self.assertEquals(u.who, "\0name")
+        self.assertEqual(u.who, "\0name")
 
     def test_parse_extensions_5questions(self):
         u = LDAPUrl("ldap:///????bindname=?")
-        self.assertEquals(len(u.extensions), 1)
-        self.assertEquals(u.who, "?")
+        self.assertEqual(len(u.extensions), 1)
+        self.assertEqual(u.who, "?")
 
     def test_parse_extensions_novalue(self):
         u = LDAPUrl("ldap:///????bindname")
-        self.assertEquals(len(u.extensions), 1)
+        self.assertEqual(len(u.extensions), 1)
         self.assertNone(u.who)
 
     @unittest.expectedFailure