Rename util func that trips pytest's default discovery.

Wouldn't matter as much under pytest-relaxed discovery, but, eh

7 files changed, 66 insertions, 66 deletions

diff --git a/tests/test_auth.py b/tests/test_auth.py
index e78397c6..e1f06cc1 100644
--- a/tests/test_auth.py
+++ b/tests/test_auth.py
@@ -32,7 +32,7 @@ from paramiko import (
 from paramiko import AUTH_FAILED, AUTH_PARTIALLY_SUCCESSFUL, AUTH_SUCCESSFUL
 from paramiko.py3compat import u
 from tests.loop import LoopSocket
-from tests.util import test_path
+from tests.util import _support
 
 _pwd = u('\u2022')
 
@@ -40,7 +40,7 @@ _pwd = u('\u2022')
 class NullServer (ServerInterface):
     paranoid_did_password = False
     paranoid_did_public_key = False
-    paranoid_key = DSSKey.from_private_key_file(test_path('test_dss.key'))
+    paranoid_key = DSSKey.from_private_key_file(_support('test_dss.key'))
 
     def get_allowed_auths(self, username):
         if username == 'slowdive':
@@ -118,7 +118,7 @@ class AuthTest (unittest.TestCase):
         self.sockc.close()
 
     def start_server(self):
-        host_key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         self.public_host_key = RSAKey(data=host_key.asbytes())
         self.ts.add_server_key(host_key)
         self.event = threading.Event()
@@ -170,7 +170,7 @@ class AuthTest (unittest.TestCase):
         self.tc.connect(hostkey=self.public_host_key)
         remain = self.tc.auth_password(username='paranoid', password='paranoid')
         self.assertEqual(['publickey'], remain)
-        key = DSSKey.from_private_key_file(test_path('test_dss.key'))
+        key = DSSKey.from_private_key_file(_support('test_dss.key'))
         remain = self.tc.auth_publickey(username='paranoid', key=key)
         self.assertEqual([], remain)
         self.verify_finished()
diff --git a/tests/test_client.py b/tests/test_client.py
index 4fe9ef4c..230739b0 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -32,7 +32,7 @@ import weakref
 import warnings
 import os
 import time
-from tests.util import test_path
+from tests.util import _support
 
 import paramiko
 from paramiko.pkey import PublicBlob
@@ -135,10 +135,10 @@ class SSHClientTest (unittest.TestCase):
             allowed_keys = FINGERPRINTS.keys()
         self.socks, addr = self.sockl.accept()
         self.ts = paramiko.Transport(self.socks)
-        keypath = test_path('test_rsa.key')
+        keypath = _support('test_rsa.key')
         host_key = paramiko.RSAKey.from_private_key_file(keypath)
         self.ts.add_server_key(host_key)
-        keypath = test_path('test_ecdsa_256.key')
+        keypath = _support('test_ecdsa_256.key')
         host_key = paramiko.ECDSAKey.from_private_key_file(keypath)
         self.ts.add_server_key(host_key)
         server = NullServer(allowed_keys=allowed_keys, public_blob=public_blob)
@@ -158,7 +158,7 @@ class SSHClientTest (unittest.TestCase):
             run_kwargs[key] = kwargs.pop(key, None)
         # Server setup
         threading.Thread(target=self._run, kwargs=run_kwargs).start()
-        host_key = paramiko.RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = paramiko.RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = paramiko.RSAKey(data=host_key.asbytes())
 
         # Client setup
@@ -204,22 +204,22 @@ class SSHClientTest (unittest.TestCase):
         """
         verify that SSHClient works with a DSA key.
         """
-        self._test_connection(key_filename=test_path('test_dss.key'))
+        self._test_connection(key_filename=_support('test_dss.key'))
 
     def test_client_rsa(self):
         """
         verify that SSHClient works with an RSA key.
         """
-        self._test_connection(key_filename=test_path('test_rsa.key'))
+        self._test_connection(key_filename=_support('test_rsa.key'))
 
     def test_2_5_client_ecdsa(self):
         """
         verify that SSHClient works with an ECDSA key.
         """
-        self._test_connection(key_filename=test_path('test_ecdsa_256.key'))
+        self._test_connection(key_filename=_support('test_ecdsa_256.key'))
 
     def test_client_ed25519(self):
-        self._test_connection(key_filename=test_path('test_ed25519.key'))
+        self._test_connection(key_filename=_support('test_ed25519.key'))
 
     def test_3_multiple_key_files(self):
         """
@@ -242,7 +242,7 @@ class SSHClientTest (unittest.TestCase):
             try:
                 self._test_connection(
                     key_filename=[
-                        test_path('test_{}.key'.format(x)) for x in attempt
+                        _support('test_{}.key'.format(x)) for x in attempt
                     ],
                     allowed_keys=[types_[x] for x in accept],
                 )
@@ -260,7 +260,7 @@ class SSHClientTest (unittest.TestCase):
         # various platforms trigger different errors here >_<
         self.assertRaises(SSHException,
             self._test_connection,
-            key_filename=[test_path('test_rsa.key')],
+            key_filename=[_support('test_rsa.key')],
             allowed_keys=['ecdsa-sha2-nistp256'],
         )
 
@@ -271,7 +271,7 @@ class SSHClientTest (unittest.TestCase):
         # NOTE: only bothered whipping up one cert per overall class/family.
         for type_ in ('rsa', 'dss', 'ecdsa_256', 'ed25519'):
             cert_name = 'test_{}.key-cert.pub'.format(type_)
-            cert_path = test_path(os.path.join('cert_support', cert_name))
+            cert_path = _support(os.path.join('cert_support', cert_name))
             self._test_connection(
                 key_filename=cert_path,
                 public_blob=PublicBlob.from_file(cert_path),
@@ -286,7 +286,7 @@ class SSHClientTest (unittest.TestCase):
         # succeeding proving that the overall flow works.
         for type_ in ('rsa', 'dss', 'ecdsa_256', 'ed25519'):
             key_name = 'test_{}.key'.format(type_)
-            key_path = test_path(os.path.join('cert_support', key_name))
+            key_path = _support(os.path.join('cert_support', key_name))
             self._test_connection(
                 key_filename=key_path,
                 public_blob=PublicBlob.from_file(
@@ -306,7 +306,7 @@ class SSHClientTest (unittest.TestCase):
         """
         threading.Thread(target=self._run).start()
         hostname = '[%s]:%d' % (self.addr, self.port)
-        key_file = test_path('test_ecdsa_256.key')
+        key_file = _support('test_ecdsa_256.key')
         public_host_key = paramiko.ECDSAKey.from_private_key_file(key_file)
 
         self.tc = paramiko.SSHClient()
@@ -329,7 +329,7 @@ class SSHClientTest (unittest.TestCase):
         """
         warnings.filterwarnings('ignore', 'tempnam.*')
 
-        host_key = paramiko.RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = paramiko.RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = paramiko.RSAKey(data=host_key.asbytes())
         fd, localname = mkstemp()
         os.close(fd)
@@ -409,7 +409,7 @@ class SSHClientTest (unittest.TestCase):
         """
         # Start the thread with a 1 second wait.
         threading.Thread(target=self._run, kwargs={'delay': 1}).start()
-        host_key = paramiko.RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = paramiko.RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = paramiko.RSAKey(data=host_key.asbytes())
 
         self.tc = paramiko.SSHClient()
@@ -436,7 +436,7 @@ class SSHClientTest (unittest.TestCase):
             # 'television' as per tests/test_pkey.py). NOTE: must use
             # key_filename, loading the actual key here with PKey will except
             # immediately; we're testing the try/except crap within Client.
-            key_filename=[test_path('test_rsa_password.key')],
+            key_filename=[_support('test_rsa_password.key')],
             # Actual password for default 'slowdive' user
             password='pygmalion',
         )
@@ -461,7 +461,7 @@ class SSHClientTest (unittest.TestCase):
         """
         kwargs = dict(
             gss_kex=True,
-            key_filename=[test_path('test_rsa.key')],
+            key_filename=[_support('test_rsa.key')],
         )
         self._test_connection(**kwargs)
 
@@ -472,7 +472,7 @@ class SSHClientTest (unittest.TestCase):
         """
         kwargs = dict(
             gss_auth=True,
-            key_filename=[test_path('test_rsa.key')],
+            key_filename=[_support('test_rsa.key')],
         )
         self._test_connection(**kwargs)
 
@@ -533,7 +533,7 @@ class SSHClientTest (unittest.TestCase):
 
         self.tc = paramiko.SSHClient()
         self.tc.set_missing_host_key_policy(paramiko.RejectPolicy())
-        host_key = ktype.from_private_key_file(test_path(kfile))
+        host_key = ktype.from_private_key_file(_support(kfile))
         known_hosts = self.tc.get_host_keys()
         known_hosts.add(hostname, host_key.get_name(), host_key)
 
diff --git a/tests/test_pkey.py b/tests/test_pkey.py
index a9205a18..be0f9465 100644
--- a/tests/test_pkey.py
+++ b/tests/test_pkey.py
@@ -30,7 +30,7 @@ import base64
 from paramiko import RSAKey, DSSKey, ECDSAKey, Ed25519Key, Message, util
 from paramiko.py3compat import StringIO, byte_chr, b, bytes, PY2
 
-from tests.util import test_path
+from tests.util import _support
 
 # from openssh's ssh-keygen
 PUB_RSA = 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAIEA049W6geFpmsljTwfvI1UmKWWJPNFI74+vNKTk4dmzkQY2yAMs6FhlvhlI8ysU4oj71ZsRYMecHbBbxdN79+JRFVYTKaLqjwGENeTd+yv4q+V2PvZv3fLnzApI3l7EJCqhWwJUHJ1jAkZzqDx0tyOL4uoZpww3nmE0kb3y21tH4c='
@@ -138,7 +138,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(exp, key)
 
     def test_2_load_rsa(self):
-        key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         self.assertEqual('ssh-rsa', key.get_name())
         exp_rsa = b(FINGER_RSA.split()[1].replace(':', ''))
         my_rsa = hexlify(key.get_fingerprint())
@@ -154,7 +154,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_3_load_rsa_password(self):
-        key = RSAKey.from_private_key_file(test_path('test_rsa_password.key'), 'television')
+        key = RSAKey.from_private_key_file(_support('test_rsa_password.key'), 'television')
         self.assertEqual('ssh-rsa', key.get_name())
         exp_rsa = b(FINGER_RSA.split()[1].replace(':', ''))
         my_rsa = hexlify(key.get_fingerprint())
@@ -163,7 +163,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(1024, key.get_bits())
 
     def test_4_load_dss(self):
-        key = DSSKey.from_private_key_file(test_path('test_dss.key'))
+        key = DSSKey.from_private_key_file(_support('test_dss.key'))
         self.assertEqual('ssh-dss', key.get_name())
         exp_dss = b(FINGER_DSS.split()[1].replace(':', ''))
         my_dss = hexlify(key.get_fingerprint())
@@ -179,7 +179,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_5_load_dss_password(self):
-        key = DSSKey.from_private_key_file(test_path('test_dss_password.key'), 'television')
+        key = DSSKey.from_private_key_file(_support('test_dss_password.key'), 'television')
         self.assertEqual('ssh-dss', key.get_name())
         exp_dss = b(FINGER_DSS.split()[1].replace(':', ''))
         my_dss = hexlify(key.get_fingerprint())
@@ -189,7 +189,7 @@ class KeyTest(unittest.TestCase):
 
     def test_6_compare_rsa(self):
         # verify that the private & public keys compare equal
-        key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         self.assertEqual(key, key)
         pub = RSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -198,7 +198,7 @@ class KeyTest(unittest.TestCase):
 
     def test_7_compare_dss(self):
         # verify that the private & public keys compare equal
-        key = DSSKey.from_private_key_file(test_path('test_dss.key'))
+        key = DSSKey.from_private_key_file(_support('test_dss.key'))
         self.assertEqual(key, key)
         pub = DSSKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -207,7 +207,7 @@ class KeyTest(unittest.TestCase):
 
     def test_8_sign_rsa(self):
         # verify that the rsa private key can sign and verify
-        key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         msg = key.sign_ssh_data(b'ice weasels')
         self.assertTrue(type(msg) is Message)
         msg.rewind()
@@ -220,7 +220,7 @@ class KeyTest(unittest.TestCase):
 
     def test_9_sign_dss(self):
         # verify that the dss private key can sign and verify
-        key = DSSKey.from_private_key_file(test_path('test_dss.key'))
+        key = DSSKey.from_private_key_file(_support('test_dss.key'))
         msg = key.sign_ssh_data(b'ice weasels')
         self.assertTrue(type(msg) is Message)
         msg.rewind()
@@ -275,7 +275,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key.get_name(), 'ecdsa-sha2-nistp521')
 
     def test_10_load_ecdsa_256(self):
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_256.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_256.key'))
         self.assertEqual('ecdsa-sha2-nistp256', key.get_name())
         exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(':', ''))
         my_ecdsa = hexlify(key.get_fingerprint())
@@ -291,7 +291,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_11_load_ecdsa_password_256(self):
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_password_256.key'), b'television')
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_256.key'), b'television')
         self.assertEqual('ecdsa-sha2-nistp256', key.get_name())
         exp_ecdsa = b(FINGER_ECDSA_256.split()[1].replace(':', ''))
         my_ecdsa = hexlify(key.get_fingerprint())
@@ -301,7 +301,7 @@ class KeyTest(unittest.TestCase):
 
     def test_12_compare_ecdsa_256(self):
         # verify that the private & public keys compare equal
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_256.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_256.key'))
         self.assertEqual(key, key)
         pub = ECDSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -310,7 +310,7 @@ class KeyTest(unittest.TestCase):
 
     def test_13_sign_ecdsa_256(self):
         # verify that the rsa private key can sign and verify
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_256.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_256.key'))
         msg = key.sign_ssh_data(b'ice weasels')
         self.assertTrue(type(msg) is Message)
         msg.rewind()
@@ -325,7 +325,7 @@ class KeyTest(unittest.TestCase):
         self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
 
     def test_14_load_ecdsa_384(self):
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_384.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_384.key'))
         self.assertEqual('ecdsa-sha2-nistp384', key.get_name())
         exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(':', ''))
         my_ecdsa = hexlify(key.get_fingerprint())
@@ -341,7 +341,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_15_load_ecdsa_password_384(self):
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_password_384.key'), b'television')
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_384.key'), b'television')
         self.assertEqual('ecdsa-sha2-nistp384', key.get_name())
         exp_ecdsa = b(FINGER_ECDSA_384.split()[1].replace(':', ''))
         my_ecdsa = hexlify(key.get_fingerprint())
@@ -351,7 +351,7 @@ class KeyTest(unittest.TestCase):
 
     def test_16_compare_ecdsa_384(self):
         # verify that the private & public keys compare equal
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_384.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_384.key'))
         self.assertEqual(key, key)
         pub = ECDSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -360,7 +360,7 @@ class KeyTest(unittest.TestCase):
 
     def test_17_sign_ecdsa_384(self):
         # verify that the rsa private key can sign and verify
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_384.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_384.key'))
         msg = key.sign_ssh_data(b'ice weasels')
         self.assertTrue(type(msg) is Message)
         msg.rewind()
@@ -375,7 +375,7 @@ class KeyTest(unittest.TestCase):
         self.assertTrue(pub.verify_ssh_sig(b'ice weasels', msg))
 
     def test_18_load_ecdsa_521(self):
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_521.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_521.key'))
         self.assertEqual('ecdsa-sha2-nistp521', key.get_name())
         exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(':', ''))
         my_ecdsa = hexlify(key.get_fingerprint())
@@ -394,7 +394,7 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, key2)
 
     def test_19_load_ecdsa_password_521(self):
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_password_521.key'), b'television')
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_password_521.key'), b'television')
         self.assertEqual('ecdsa-sha2-nistp521', key.get_name())
         exp_ecdsa = b(FINGER_ECDSA_521.split()[1].replace(':', ''))
         my_ecdsa = hexlify(key.get_fingerprint())
@@ -404,7 +404,7 @@ class KeyTest(unittest.TestCase):
 
     def test_20_compare_ecdsa_521(self):
         # verify that the private & public keys compare equal
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_521.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_521.key'))
         self.assertEqual(key, key)
         pub = ECDSAKey(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -413,7 +413,7 @@ class KeyTest(unittest.TestCase):
 
     def test_21_sign_ecdsa_521(self):
         # verify that the rsa private key can sign and verify
-        key = ECDSAKey.from_private_key_file(test_path('test_ecdsa_521.key'))
+        key = ECDSAKey.from_private_key_file(_support('test_ecdsa_521.key'))
         msg = key.sign_ssh_data(b'ice weasels')
         self.assertTrue(type(msg) is Message)
         msg.rewind()
@@ -429,7 +429,7 @@ class KeyTest(unittest.TestCase):
 
     def test_salt_size(self):
         # Read an existing encrypted private key
-        file_ = test_path('test_rsa_password.key')
+        file_ = _support('test_rsa_password.key')
         password = 'television'
         newfile = file_ + '.new'
         newpassword = 'radio'
@@ -446,20 +446,20 @@ class KeyTest(unittest.TestCase):
             os.remove(newfile)
 
     def test_stringification(self):
-        key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         comparable = TEST_KEY_BYTESTR_2 if PY2 else TEST_KEY_BYTESTR_3
         self.assertEqual(str(key), comparable)
 
     def test_ed25519(self):
-        key1 = Ed25519Key.from_private_key_file(test_path('test_ed25519.key'))
+        key1 = Ed25519Key.from_private_key_file(_support('test_ed25519.key'))
         key2 = Ed25519Key.from_private_key_file(
-            test_path('test_ed25519_password.key'), b'abc123'
+            _support('test_ed25519_password.key'), b'abc123'
         )
         self.assertNotEqual(key1.asbytes(), key2.asbytes())
 
     def test_ed25519_compare(self):
         # verify that the private & public keys compare equal
-        key = Ed25519Key.from_private_key_file(test_path('test_ed25519.key'))
+        key = Ed25519Key.from_private_key_file(_support('test_ed25519.key'))
         self.assertEqual(key, key)
         pub = Ed25519Key(data=key.asbytes())
         self.assertTrue(key.can_sign())
@@ -467,14 +467,14 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(key, pub)
 
     def test_ed25519_load_from_file_obj(self):
-        with open(test_path('test_ed25519.key')) as pkey_fileobj:
+        with open(_support('test_ed25519.key')) as pkey_fileobj:
             key = Ed25519Key.from_private_key(pkey_fileobj)
         self.assertEqual(key, key)
         self.assertTrue(key.can_sign())
 
     def test_keyfile_is_actually_encrypted(self):
         # Read an existing encrypted private key
-        file_ = test_path('test_rsa_password.key')
+        file_ = _support('test_rsa_password.key')
         password = 'television'
         newfile = file_ + '.new'
         newpassword = 'radio'
@@ -492,10 +492,10 @@ class KeyTest(unittest.TestCase):
         # test_client.py; this and nearby cert tests are more about the gritty
         # details.
         # PKey.load_certificate
-        key_path = test_path(os.path.join('cert_support', 'test_rsa.key'))
+        key_path = _support(os.path.join('cert_support', 'test_rsa.key'))
         key = RSAKey.from_private_key_file(key_path)
         self.assertTrue(key.public_blob is None)
-        cert_path = test_path(
+        cert_path = _support(
             os.path.join('cert_support', 'test_rsa.key-cert.pub')
         )
         key.load_certificate(cert_path)
@@ -514,10 +514,10 @@ class KeyTest(unittest.TestCase):
         self.assertEqual(msg.get_int64(), 1234)
 
         # Prevented from loading certificate that doesn't match
-        key_path = test_path(os.path.join('cert_support', 'test_ed25519.key'))
+        key_path = _support(os.path.join('cert_support', 'test_ed25519.key'))
         key1 = Ed25519Key.from_private_key_file(key_path)
         self.assertRaises(
             ValueError,
             key1.load_certificate,
-            test_path('test_rsa.key-cert.pub'),
+            _support('test_rsa.key-cert.pub'),
         )
diff --git a/tests/test_sftp.py b/tests/test_sftp.py
index 4fc27dc9..7264baeb 100755
--- a/tests/test_sftp.py
+++ b/tests/test_sftp.py
@@ -38,7 +38,7 @@ from paramiko.common import o777, o600, o666, o644
 from tests import skipUnlessBuiltin
 from tests.stub_sftp import StubServer, StubSFTPServer
 from tests.loop import LoopSocket
-from tests.util import test_path
+from tests.util import _support
 import paramiko.util
 from paramiko.sftp_attr import SFTPAttributes
 
@@ -139,7 +139,7 @@ class SFTPTest (unittest.TestCase):
         tc = paramiko.Transport(sockc)
         ts = paramiko.Transport(socks)
 
-        host_key = paramiko.RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = paramiko.RSAKey.from_private_key_file(_support('test_rsa.key'))
         ts.add_server_key(host_key)
         event = threading.Event()
         server = StubServer()
diff --git a/tests/test_ssh_gss.py b/tests/test_ssh_gss.py
index d8d05d2b..081d942b 100644
--- a/tests/test_ssh_gss.py
+++ b/tests/test_ssh_gss.py
@@ -29,7 +29,7 @@ import unittest
 
 import paramiko
 
-from tests.util import test_path
+from tests.util import _support
 from tests.test_client import FINGERPRINTS
 
 class NullServer (paramiko.ServerInterface):
@@ -148,6 +148,6 @@ class GSSAuthTest(unittest.TestCase):
         Failed gssapi-with-mic auth doesn't prevent subsequent key auth from succeeding
         """
         self.hostname = "this_host_does_not_exists_and_causes_a_GSSAPI-exception"
-        self._test_connection(key_filename=[test_path('test_rsa.key')],
+        self._test_connection(key_filename=[_support('test_rsa.key')],
                               allow_agent=False,
                               look_for_keys=False)
diff --git a/tests/test_transport.py b/tests/test_transport.py
index 3e352919..f4cf622f 100644
--- a/tests/test_transport.py
+++ b/tests/test_transport.py
@@ -45,7 +45,7 @@ from paramiko.py3compat import bytes
 from paramiko.message import Message
 from tests import skipUnlessBuiltin
 from tests.loop import LoopSocket
-from tests.util import test_path
+from tests.util import _support
 
 
 LONG_BANNER = """\
@@ -64,7 +64,7 @@ Maybe.
 class NullServer (ServerInterface):
     paranoid_did_password = False
     paranoid_did_public_key = False
-    paranoid_key = DSSKey.from_private_key_file(test_path('test_dss.key'))
+    paranoid_key = DSSKey.from_private_key_file(_support('test_dss.key'))
 
     def get_allowed_auths(self, username):
         if username == 'slowdive':
@@ -130,7 +130,7 @@ class TransportTest(unittest.TestCase):
         self.sockc.close()
 
     def setup_test_server(self, client_options=None, server_options=None):
-        host_key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = RSAKey(data=host_key.asbytes())
         self.ts.add_server_key(host_key)
 
@@ -189,7 +189,7 @@ class TransportTest(unittest.TestCase):
         loopback sockets.  this is hardly "simple" but it's simpler than the
         later tests. :)
         """
-        host_key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = RSAKey(data=host_key.asbytes())
         self.ts.add_server_key(host_key)
         event = threading.Event()
@@ -214,7 +214,7 @@ class TransportTest(unittest.TestCase):
         """
         verify that a long banner doesn't mess up the handshake.
         """
-        host_key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = RSAKey(data=host_key.asbytes())
         self.ts.add_server_key(host_key)
         event = threading.Event()
@@ -829,7 +829,7 @@ class TransportTest(unittest.TestCase):
         # be fine. Even tho it's a bit squicky.
         self.tc.packetizer = SlowPacketizer(self.tc.sock)
         # Continue with regular test red tape.
-        host_key = RSAKey.from_private_key_file(test_path('test_rsa.key'))
+        host_key = RSAKey.from_private_key_file(_support('test_rsa.key'))
         public_host_key = RSAKey(data=host_key.asbytes())
         self.ts.add_server_key(host_key)
         event = threading.Event()
diff --git a/tests/util.py b/tests/util.py
index c1b43da8..55aedc98 100644
--- a/tests/util.py
+++ b/tests/util.py
@@ -2,5 +2,5 @@ import os
 
 root_path = os.path.dirname(os.path.realpath(__file__))
 
-def test_path(filename):
+def _support(filename):
     return os.path.join(root_path, filename)