rename var

5 files changed, 45 insertions, 45 deletions

diff --git a/psutil/tests/__init__.py b/psutil/tests/__init__.py
index ec406a27..cc409161 100644
--- a/psutil/tests/__init__.py
+++ b/psutil/tests/__init__.py
@@ -73,7 +73,7 @@ else:
 
 __all__ = [
     # constants
-    'APPVEYOR', 'DEVNULL', 'GLOBAL_TIMEOUT', 'MEMORY_TOLERANCE', 'NO_RETRIES',
+    'APPVEYOR', 'DEVNULL', 'GLOBAL_TIMEOUT', 'SYSMEM_TOLERANCE', 'NO_RETRIES',
     'PYPY', 'PYTHON_EXE', 'ROOT_DIR', 'SCRIPTS_DIR', 'TESTFN_PREFIX',
     'UNICODE_SUFFIX', 'INVALID_UNICODE_SUFFIX', 'TOX', 'TRAVIS', 'CIRRUS',
     'CI_TESTING', 'VALID_PROC_STATUSES',
@@ -128,7 +128,7 @@ CI_TESTING = TRAVIS or APPVEYOR or CIRRUS
 # how many times retry_on_failure() decorator will retry
 NO_RETRIES = 10
 # bytes tolerance for system-wide memory related tests
-MEMORY_TOLERANCE = 500 * 1024  # 500KB
+SYSMEM_TOLERANCE = 500 * 1024  # 500KB
 # the timeout used in functions which have to wait
 GLOBAL_TIMEOUT = 5
 # be more tolerant if we're on travis / appveyor in order to avoid
diff --git a/psutil/tests/test_aix.py b/psutil/tests/test_aix.py
index 7171232e..9a80106c 100755
--- a/psutil/tests/test_aix.py
+++ b/psutil/tests/test_aix.py
@@ -37,17 +37,17 @@ class AIXSpecificTestCase(unittest.TestCase):
 
         psutil_result = psutil.virtual_memory()
 
-        # MEMORY_TOLERANCE from psutil.tests is not enough. For some reason
+        # SYSMEM_TOLERANCE from psutil.tests is not enough. For some reason
         # we're seeing differences of ~1.2 MB. 2 MB is still a good tolerance
         # when compared to GBs.
-        MEMORY_TOLERANCE = 2 * KB * KB   # 2 MB
+        SYSMEM_TOLERANCE = 2 * KB * KB   # 2 MB
         self.assertEqual(psutil_result.total, total)
         self.assertAlmostEqual(
-            psutil_result.used, used, delta=MEMORY_TOLERANCE)
+            psutil_result.used, used, delta=SYSMEM_TOLERANCE)
         self.assertAlmostEqual(
-            psutil_result.available, available, delta=MEMORY_TOLERANCE)
+            psutil_result.available, available, delta=SYSMEM_TOLERANCE)
         self.assertAlmostEqual(
-            psutil_result.free, free, delta=MEMORY_TOLERANCE)
+            psutil_result.free, free, delta=SYSMEM_TOLERANCE)
 
     def test_swap_memory(self):
         out = sh('/usr/sbin/lsps -a')
diff --git a/psutil/tests/test_bsd.py b/psutil/tests/test_bsd.py
index 899875d0..4b348775 100755
--- a/psutil/tests/test_bsd.py
+++ b/psutil/tests/test_bsd.py
@@ -22,7 +22,7 @@ from psutil import NETBSD
 from psutil import OPENBSD
 from psutil.tests import get_test_subprocess
 from psutil.tests import HAS_BATTERY
-from psutil.tests import MEMORY_TOLERANCE
+from psutil.tests import SYSMEM_TOLERANCE
 from psutil.tests import reap_children
 from psutil.tests import retry_on_failure
 from psutil.tests import sh
@@ -279,37 +279,37 @@ class FreeBSDSystemTestCase(unittest.TestCase):
     def test_vmem_active(self):
         syst = sysctl("vm.stats.vm.v_active_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().active, syst,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_inactive(self):
         syst = sysctl("vm.stats.vm.v_inactive_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().inactive, syst,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_wired(self):
         syst = sysctl("vm.stats.vm.v_wire_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().wired, syst,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_cached(self):
         syst = sysctl("vm.stats.vm.v_cache_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().cached, syst,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_free(self):
         syst = sysctl("vm.stats.vm.v_free_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().free, syst,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_buffers(self):
         syst = sysctl("vfs.bufspace")
         self.assertAlmostEqual(psutil.virtual_memory().buffers, syst,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     # --- virtual_memory(); tests against muse
 
@@ -323,42 +323,42 @@ class FreeBSDSystemTestCase(unittest.TestCase):
     def test_muse_vmem_active(self):
         num = muse('Active')
         self.assertAlmostEqual(psutil.virtual_memory().active, num,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_inactive(self):
         num = muse('Inactive')
         self.assertAlmostEqual(psutil.virtual_memory().inactive, num,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_wired(self):
         num = muse('Wired')
         self.assertAlmostEqual(psutil.virtual_memory().wired, num,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_cached(self):
         num = muse('Cache')
         self.assertAlmostEqual(psutil.virtual_memory().cached, num,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_free(self):
         num = muse('Free')
         self.assertAlmostEqual(psutil.virtual_memory().free, num,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_buffers(self):
         num = muse('Buffer')
         self.assertAlmostEqual(psutil.virtual_memory().buffers, num,
-                               delta=MEMORY_TOLERANCE)
+                               delta=SYSMEM_TOLERANCE)
 
     def test_cpu_stats_ctx_switches(self):
         self.assertAlmostEqual(psutil.cpu_stats().ctx_switches,
@@ -387,17 +387,17 @@ class FreeBSDSystemTestCase(unittest.TestCase):
     def test_swapmem_free(self):
         total, used, free = self.parse_swapinfo()
         self.assertAlmostEqual(
-            psutil.swap_memory().free, free, delta=MEMORY_TOLERANCE)
+            psutil.swap_memory().free, free, delta=SYSMEM_TOLERANCE)
 
     def test_swapmem_used(self):
         total, used, free = self.parse_swapinfo()
         self.assertAlmostEqual(
-            psutil.swap_memory().used, used, delta=MEMORY_TOLERANCE)
+            psutil.swap_memory().used, used, delta=SYSMEM_TOLERANCE)
 
     def test_swapmem_total(self):
         total, used, free = self.parse_swapinfo()
         self.assertAlmostEqual(
-            psutil.swap_memory().total, total, delta=MEMORY_TOLERANCE)
+            psutil.swap_memory().total, total, delta=SYSMEM_TOLERANCE)
 
     # --- others
 
@@ -511,27 +511,27 @@ class NetBSDTestCase(unittest.TestCase):
     def test_vmem_free(self):
         self.assertAlmostEqual(
             psutil.virtual_memory().free, self.parse_meminfo("MemFree:"),
-            delta=MEMORY_TOLERANCE)
+            delta=SYSMEM_TOLERANCE)
 
     def test_vmem_buffers(self):
         self.assertAlmostEqual(
             psutil.virtual_memory().buffers, self.parse_meminfo("Buffers:"),
-            delta=MEMORY_TOLERANCE)
+            delta=SYSMEM_TOLERANCE)
 
     def test_vmem_shared(self):
         self.assertAlmostEqual(
             psutil.virtual_memory().shared, self.parse_meminfo("MemShared:"),
-            delta=MEMORY_TOLERANCE)
+            delta=SYSMEM_TOLERANCE)
 
     def test_swapmem_total(self):
         self.assertAlmostEqual(
             psutil.swap_memory().total, self.parse_meminfo("SwapTotal:"),
-            delta=MEMORY_TOLERANCE)
+            delta=SYSMEM_TOLERANCE)
 
     def test_swapmem_free(self):
         self.assertAlmostEqual(
             psutil.swap_memory().free, self.parse_meminfo("SwapFree:"),
-            delta=MEMORY_TOLERANCE)
+            delta=SYSMEM_TOLERANCE)
 
     def test_swapmem_used(self):
         smem = psutil.swap_memory()
diff --git a/psutil/tests/test_linux.py b/psutil/tests/test_linux.py
index d529ae7c..30fadd2b 100755
--- a/psutil/tests/test_linux.py
+++ b/psutil/tests/test_linux.py
@@ -33,7 +33,7 @@ from psutil.tests import HAS_BATTERY
 from psutil.tests import HAS_CPU_FREQ
 from psutil.tests import HAS_GETLOADAVG
 from psutil.tests import HAS_RLIMIT
-from psutil.tests import MEMORY_TOLERANCE
+from psutil.tests import SYSMEM_TOLERANCE
 from psutil.tests import mock
 from psutil.tests import PYPY
 from psutil.tests import pyrun
@@ -211,7 +211,7 @@ class TestSystemVirtualMemory(unittest.TestCase):
         free_value = free.used
         psutil_value = psutil.virtual_memory().used
         self.assertAlmostEqual(
-            free_value, psutil_value, delta=MEMORY_TOLERANCE,
+            free_value, psutil_value, delta=SYSMEM_TOLERANCE,
             msg='%s %s \n%s' % (free_value, psutil_value, free.output))
 
     @unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@@ -220,14 +220,14 @@ class TestSystemVirtualMemory(unittest.TestCase):
         vmstat_value = vmstat('free memory') * 1024
         psutil_value = psutil.virtual_memory().free
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
+            vmstat_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_buffers(self):
         vmstat_value = vmstat('buffer memory') * 1024
         psutil_value = psutil.virtual_memory().buffers
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
+            vmstat_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     # https://travis-ci.org/giampaolo/psutil/jobs/226719664
     @unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@@ -236,7 +236,7 @@ class TestSystemVirtualMemory(unittest.TestCase):
         vmstat_value = vmstat('active memory') * 1024
         psutil_value = psutil.virtual_memory().active
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
+            vmstat_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     # https://travis-ci.org/giampaolo/psutil/jobs/227242952
     @unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@@ -245,7 +245,7 @@ class TestSystemVirtualMemory(unittest.TestCase):
         vmstat_value = vmstat('inactive memory') * 1024
         psutil_value = psutil.virtual_memory().inactive
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=MEMORY_TOLERANCE)
+            vmstat_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_shared(self):
@@ -255,7 +255,7 @@ class TestSystemVirtualMemory(unittest.TestCase):
             raise unittest.SkipTest("free does not support 'shared' column")
         psutil_value = psutil.virtual_memory().shared
         self.assertAlmostEqual(
-            free_value, psutil_value, delta=MEMORY_TOLERANCE,
+            free_value, psutil_value, delta=SYSMEM_TOLERANCE,
             msg='%s %s \n%s' % (free_value, psutil_value, free.output))
 
     @retry_on_failure()
@@ -270,7 +270,7 @@ class TestSystemVirtualMemory(unittest.TestCase):
             free_value = int(lines[1].split()[-1])
             psutil_value = psutil.virtual_memory().available
             self.assertAlmostEqual(
-                free_value, psutil_value, delta=MEMORY_TOLERANCE,
+                free_value, psutil_value, delta=SYSMEM_TOLERANCE,
                 msg='%s %s \n%s' % (free_value, psutil_value, out))
 
     def test_warnings_on_misses(self):
@@ -508,21 +508,21 @@ class TestSystemSwapMemory(unittest.TestCase):
         free_value = free_swap().total
         psutil_value = psutil.swap_memory().total
         return self.assertAlmostEqual(
-            free_value, psutil_value, delta=MEMORY_TOLERANCE)
+            free_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_used(self):
         free_value = free_swap().used
         psutil_value = psutil.swap_memory().used
         return self.assertAlmostEqual(
-            free_value, psutil_value, delta=MEMORY_TOLERANCE)
+            free_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_free(self):
         free_value = free_swap().free
         psutil_value = psutil.swap_memory().free
         return self.assertAlmostEqual(
-            free_value, psutil_value, delta=MEMORY_TOLERANCE)
+            free_value, psutil_value, delta=SYSMEM_TOLERANCE)
 
     def test_missing_sin_sout(self):
         with mock.patch('psutil._common.open', create=True) as m:
@@ -572,7 +572,7 @@ class TestSystemSwapMemory(unittest.TestCase):
         total *= unit_multiplier
         free *= unit_multiplier
         self.assertEqual(swap.total, total)
-        self.assertAlmostEqual(swap.free, free, delta=MEMORY_TOLERANCE)
+        self.assertAlmostEqual(swap.free, free, delta=SYSMEM_TOLERANCE)
 
     def test_emulate_meminfo_has_no_metrics(self):
         # Emulate a case where /proc/meminfo provides no swap metrics
diff --git a/psutil/tests/test_osx.py b/psutil/tests/test_osx.py
index e4e77f93..c4008b9d 100755
--- a/psutil/tests/test_osx.py
+++ b/psutil/tests/test_osx.py
@@ -15,7 +15,7 @@ from psutil import MACOS
 from psutil.tests import create_zombie_proc
 from psutil.tests import get_test_subprocess
 from psutil.tests import HAS_BATTERY
-from psutil.tests import MEMORY_TOLERANCE
+from psutil.tests import SYSMEM_TOLERANCE
 from psutil.tests import reap_children
 from psutil.tests import retry_on_failure
 from psutil.tests import sh
@@ -219,25 +219,25 @@ class TestSystemAPIs(unittest.TestCase):
     def test_vmem_free(self):
         vmstat_val = vm_stat("free")
         psutil_val = psutil.virtual_memory().free
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_active(self):
         vmstat_val = vm_stat("active")
         psutil_val = psutil.virtual_memory().active
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_inactive(self):
         vmstat_val = vm_stat("inactive")
         psutil_val = psutil.virtual_memory().inactive
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=SYSMEM_TOLERANCE)
 
     @retry_on_failure()
     def test_vmem_wired(self):
         vmstat_val = vm_stat("wired")
         psutil_val = psutil.virtual_memory().wired
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=MEMORY_TOLERANCE)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=SYSMEM_TOLERANCE)
 
     # --- swap mem