Merge pull request #2252 from Captain-Coder/balance-fix

Fixes #2188, added test cases for byte formatting methods

Tribler/Main/Utility/utility.py

@@ -87,17 +87,18 @@ def flush_config(self):
 def speed_format(s):
     text = ''
     if s is not None:
-        if s < 102400:
+        s_abs = abs(s)
+        if s_abs < 102400:
             text = '%2.1f KB/s' % (s / 1024.0)
-        elif s < 1022797:
+        elif s_abs < 1022797:
             text = '%d KB/s' % (s // 1024)
-        elif s < 104857600:
+        elif s_abs < 104857600:
             text = '%2.1f MB/s' % (s / 1048576.0)
-        elif s < 1047527425:
+        elif s_abs < 1047527425:
             text = '%d MB/s' % (s // 1048576)
-        elif s < 107374182400:
+        elif s_abs < 107374182400:
             text = '%2.1f GB/s' % (s / 1073741824.0)
-        elif s < 1072668082177:
+        elif s_abs < 1072668082177:
             text = '%d GB/s' % (s // 1073741824)
         else:
             text = '%2.1f TB/s' % (s / 1099511627776.0)
@@ -179,17 +180,19 @@ def size_format(s, truncate=None, stopearly=None, applylabel=True, rawsize=False
     if truncate is None:
         truncate = 2
 
-    if ((s < 1024) and showbytes and stopearly is None) or stopearly == "Byte":
+    s_abs = abs(s)
+
+    if ((s_abs < 1024) and showbytes and stopearly is None) or stopearly == "Byte" or stopearly == "B":
         truncate = 0
         size = s
         text = u"Byte"
-    elif ((s < 1048576) and stopearly is None) or stopearly == "KB":
+    elif ((s_abs < 1048576) and stopearly is None) or stopearly == "KB":
         size = (s / 1024.0)
         text = u"KB"
-    elif ((s < 1073741824) and stopearly is None) or stopearly == "MB":
+    elif ((s_abs < 1073741824) and stopearly is None) or stopearly == "MB":
         size = (s / 1048576.0)
         text = u"MB"
-    elif ((s < 1099511627776) and stopearly is None) or stopearly == "GB":
+    elif ((s_abs < 1099511627776) and stopearly is None) or stopearly == "GB":
         size = (s / 1073741824.0)
         text = u"GB"
     else:

Tribler/Test/Main/Utility/test_size_format.py

@@ -0,0 +1,128 @@
+from Tribler.Test.test_as_server import AbstractServer
+from Tribler.Main.Utility.utility import size_format
+
+Unit = 1024
+KB = Unit
+MB = KB * Unit
+GB = MB * Unit
+TB = GB * Unit
+PB = TB * Unit
+EB = PB * Unit
+
+
+class TriblerMainUtilitySizeFormat(AbstractServer):
+
+    def test_size_format_bytes(self):
+        result = size_format(123)
+        self.assertEqual("0.12 KB", result)
+
+    def test_size_format_kilo_bytes(self):
+        result = size_format(123 * KB)
+        self.assertEqual("123.00 KB", result)
+
+    def test_size_format_mega_bytes(self):
+        result = size_format(123 * MB)
+        self.assertEqual("123.00 MB", result)
+
+    def test_size_format_giga_bytes(self):
+        result = size_format(123 * GB)
+        self.assertEqual("123.00 GB", result)
+
+    def test_size_format_terra_bytes(self):
+        result = size_format(123 * TB)
+        self.assertEqual("123.00 TB", result)
+
+    def test_size_format_bytes_textonly(self):
+        # this one is an odd one out, the textonly option returns Byte as unit instead of B
+        result = size_format(123, textonly=True, showbytes=True)
+        self.assertEqual("Byte", result)
+
+    def test_size_format_kilo_bytes_textonly(self):
+        result = size_format(123 * KB, textonly=True)
+        self.assertEqual("KB", result)
+
+    def test_size_format_bytes_labelonly(self):
+        # this one is regular again as opposed to the textonly version
+        result = size_format(123, labelonly=True, showbytes=True)
+        self.assertEqual("B", result)
+
+    def test_size_format_kilo_bytes_labelonly(self):
+        result = size_format(123 * KB, labelonly=True)
+        self.assertEqual("KB", result)
+
+    def test_size_format_bytes_showbytes(self):
+        result = size_format(123, showbytes=True)
+        self.assertEqual("123 B", result)
+
+    def test_size_format_kilo_bytes_showbytes(self):
+        result = size_format(123 * KB, showbytes=True)
+        # This might not be what one expects, however currently the input has to be smaller than KB to show as bytes
+        self.assertEqual("123.00 KB", result)
+
+    def test_size_format_bytes_textonly_showbytes(self):
+        result = size_format(123, textonly=True, showbytes=True)
+        self.assertEqual("Byte", result)
+
+    def test_size_format_kilo_bytes_labelonly_showbytes(self):
+        result = size_format(123 * KB, labelonly=True, showbytes=True)
+        self.assertEqual("KB", result)
+
+    def test_size_format_terra_bytes_stopearly(self):
+        result = size_format(123 * TB, stopearly="B")
+        self.assertEqual("135239930216448 B", result)
+
+    def test_size_format_terra_bytes_stopearly_byte(self):
+        result = size_format(123 * TB, stopearly="Byte")
+        self.assertEqual("135239930216448 B", result)
+
+    def test_size_format_terra_bytes_stopearly_kb(self):
+        result = size_format(123 * TB, stopearly="KB")
+        self.assertEqual("132070244352.00 KB", result)
+
+    def test_size_format_terra_bytes_stopearly_mb(self):
+        result = size_format(123 * TB, stopearly="MB")
+        self.assertEqual("128974848.00 MB", result)
+
+    def test_size_format_terra_bytes_stopearly_gb(self):
+        result = size_format(123 * TB, stopearly="GB")
+        self.assertEqual("125952.00 GB", result)
+
+    def test_size_format_bytes_size(self):
+        result = size_format(123, rawsize=True, showbytes=True)
+        self.assertEqual(123, result)
+
+    def test_size_format_kilo_bytes_size(self):
+        result = size_format(123 * KB, rawsize=True)
+        self.assertEqual(123, result)
+
+    def test_size_format_mega_bytes_size(self):
+        result = size_format(123 * MB, rawsize=True)
+        self.assertEqual(123, result)
+
+    def test_size_format_giga_bytes_size(self):
+        result = size_format(123 * GB, rawsize=True)
+        self.assertEqual(123, result)
+
+    def test_size_format_terra_bytes_size(self):
+        result = size_format(123 * TB, rawsize=True)
+        self.assertEqual(123, result)
+
+    def test_size_format_giga_bytes_truncate_0(self):
+        result = size_format(123.123 * GB, truncate=0)
+        self.assertEqual("123 GB", result)
+
+    def test_size_format_giga_bytes_truncate_1(self):
+        result = size_format(123.123 * GB, truncate=1)
+        self.assertEqual("123.1 GB", result)
+
+    def test_size_format_giga_bytes_truncate_2(self):
+        result = size_format(123.123 * GB, truncate=2)
+        self.assertEqual("123.12 GB", result)
+
+    def test_size_format_giga_bytes_no_label(self):
+        result = size_format(123.123 * GB, applylabel=False)
+        self.assertEqual("123.12", result)
+
+    def test_size_format_negative(self):
+        result = size_format(-123 * MB)
+        self.assertEqual("-123.00 MB", result)

Tribler/Test/Main/Utility/test_speed_format.py

@@ -0,0 +1,69 @@
+from Tribler.Test.test_as_server import AbstractServer
+from Tribler.Main.Utility.utility import speed_format
+
+Unit = 1024
+KB = Unit
+MB = KB * Unit
+GB = MB * Unit
+TB = GB * Unit
+PB = TB * Unit
+EB = PB * Unit
+
+
+class TriblerMainUtilitySpeedFormat(AbstractServer):
+
+    def test_speed_format_bytes(self):
+        result = speed_format(Unit * 0.5)
+        self.assertEqual("0.5 KB/s", result)
+
+    def test_speed_format_kilo_bytes(self):
+        result = speed_format(12 * KB)
+        self.assertEqual("12.0 KB/s", result)
+
+    def test_speed_format_more_kilo_bytes(self):
+        result = speed_format(123 * KB)
+        self.assertEqual("123 KB/s", result)
+
+    def test_speed_format_almost_mega_byte(self):
+        result = speed_format(1 * MB - 2 * KB)
+        self.assertEqual("1.0 MB/s", result)
+
+    def test_speed_format_mega_byte(self):
+        result = speed_format(12 * MB)
+        self.assertEqual("12.0 MB/s", result)
+
+    def test_speed_format_more_mega_bytes(self):
+        result = speed_format(123 * MB)
+        self.assertEqual("123 MB/s", result)
+
+    def test_speed_format_almost_giga_byte(self):
+        result = speed_format(1 * GB - 2 * MB)
+        self.assertEqual("1.0 GB/s", result)
+
+    def test_speed_format_giga_byte(self):
+        result = speed_format(12 * GB)
+        self.assertEqual("12.0 GB/s", result)
+
+    def test_speed_format_more_giga_bytes(self):
+        result = speed_format(123 * GB)
+        self.assertEqual("123 GB/s", result)
+
+    def test_speed_format_almost_terra_byte(self):
+        result = speed_format(1 * TB - 2 * GB)
+        self.assertEqual("1.0 TB/s", result)
+
+    def test_speed_format_terra_byte(self):
+        result = speed_format(12 * TB)
+        self.assertEqual("12.0 TB/s", result)
+
+    def test_speed_format_more_terra_bytes(self):
+        result = speed_format(123 * TB)
+        self.assertEqual("123.0 TB/s", result)
+
+    def test_speed_format_none(self):
+        result = speed_format(None)
+        self.assertEqual("", result)
+
+    def test_speed_format_negative_mega_byte(self):
+        result = speed_format(-12 * MB)
+        self.assertEqual("-12.0 MB/s", result)