New upstream version 1.19.0.upstream/1.19.0

6 files changed, 361 insertions, 185 deletions

diff --git a/test/test_downloader.py b/test/test_downloader.py
index 42b5c72..9350ce4 100644
--- a/test/test_downloader.py
+++ b/test/test_downloader.py
@@ -22,7 +22,7 @@ import http.server
 
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from gallery_dl import downloader, extractor, output, config, util  # noqa E402
+from gallery_dl import downloader, extractor, output, config, path  # noqa E402
 
 
 class MockDownloaderModule(Mock):
@@ -33,7 +33,7 @@ class FakeJob():
 
     def __init__(self):
         self.extractor = extractor.find("test:")
-        self.pathfmt = util.PathFormat(self.extractor)
+        self.pathfmt = path.PathFormat(self.extractor)
         self.out = output.NullOutput()
         self.get_logger = logging.getLogger
 
diff --git a/test/test_formatter.py b/test/test_formatter.py
new file mode 100644
index 0000000..70201f3
--- /dev/null
+++ b/test/test_formatter.py
@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2021 Mike Fährmann
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+
+import os
+import sys
+import unittest
+import datetime
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from gallery_dl import formatter  # noqa E402
+
+
+class TestFormatter(unittest.TestCase):
+
+    kwdict = {
+        "a": "hElLo wOrLd",
+        "b": "äöü",
+        "d": {"a": "foo", "b": 0, "c": None},
+        "l": ["a", "b", "c"],
+        "n": None,
+        "s": " \n\r\tSPACE    ",
+        "u": "'< / >'",
+        "t": 1262304000,
+        "dt": datetime.datetime(2010, 1, 1),
+        "name": "Name",
+        "title1": "Title",
+        "title2": "",
+        "title3": None,
+        "title4": 0,
+    }
+
+    def test_conversions(self):
+        self._run_test("{a!l}", "hello world")
+        self._run_test("{a!u}", "HELLO WORLD")
+        self._run_test("{a!c}", "Hello world")
+        self._run_test("{a!C}", "Hello World")
+        self._run_test("{s!t}", "SPACE")
+        self._run_test("{a!U}", self.kwdict["a"])
+        self._run_test("{u!U}", "'< / >'")
+        self._run_test("{a!s}", self.kwdict["a"])
+        self._run_test("{a!r}", "'" + self.kwdict["a"] + "'")
+        self._run_test("{a!a}", "'" + self.kwdict["a"] + "'")
+        self._run_test("{b!a}", "'\\xe4\\xf6\\xfc'")
+        self._run_test("{a!S}", self.kwdict["a"])
+        self._run_test("{l!S}", "a, b, c")
+        self._run_test("{n!S}", "")
+        self._run_test("{t!d}", datetime.datetime(2010, 1, 1))
+        self._run_test("{t!d:%Y-%m-%d}", "2010-01-01")
+        self._run_test("{dt!T}", "1262304000")
+        self._run_test("{l!j}", '["a", "b", "c"]')
+
+        with self.assertRaises(KeyError):
+            self._run_test("{a!q}", "hello world")
+
+    def test_optional(self):
+        self._run_test("{name}{title1}", "NameTitle")
+        self._run_test("{name}{title1:?//}", "NameTitle")
+        self._run_test("{name}{title1:? **/''/}", "Name **Title''")
+
+        self._run_test("{name}{title2}", "Name")
+        self._run_test("{name}{title2:?//}", "Name")
+        self._run_test("{name}{title2:? **/''/}", "Name")
+
+        self._run_test("{name}{title3}", "NameNone")
+        self._run_test("{name}{title3:?//}", "Name")
+        self._run_test("{name}{title3:? **/''/}", "Name")
+
+        self._run_test("{name}{title4}", "Name0")
+        self._run_test("{name}{title4:?//}", "Name")
+        self._run_test("{name}{title4:? **/''/}", "Name")
+
+    def test_missing(self):
+        replacement = "None"
+
+        self._run_test("{missing}", replacement)
+        self._run_test("{missing.attr}", replacement)
+        self._run_test("{missing[key]}", replacement)
+        self._run_test("{missing:?a//}", "")
+
+        self._run_test("{name[missing]}", replacement)
+        self._run_test("{name[missing].attr}", replacement)
+        self._run_test("{name[missing][key]}", replacement)
+        self._run_test("{name[missing]:?a//}", "")
+
+    def test_missing_custom_default(self):
+        replacement = default = "foobar"
+        self._run_test("{missing}"     , replacement, default)
+        self._run_test("{missing.attr}", replacement, default)
+        self._run_test("{missing[key]}", replacement, default)
+        self._run_test("{missing:?a//}", "a" + default, default)
+
+    def test_alternative(self):
+        self._run_test("{a|z}"    , "hElLo wOrLd")
+        self._run_test("{z|a}"    , "hElLo wOrLd")
+        self._run_test("{z|y|a}"  , "hElLo wOrLd")
+        self._run_test("{z|y|x|a}", "hElLo wOrLd")
+        self._run_test("{z|n|a|y}", "hElLo wOrLd")
+
+        self._run_test("{z|a!C}"      , "Hello World")
+        self._run_test("{z|a:Rh/C/}"  , "CElLo wOrLd")
+        self._run_test("{z|a!C:RH/C/}", "Cello World")
+        self._run_test("{z|y|x:?</>/}", "")
+
+        self._run_test("{d[c]|d[b]|d[a]}", "foo")
+        self._run_test("{d[a]|d[b]|d[c]}", "foo")
+        self._run_test("{d[z]|d[y]|d[x]}", "None")
+
+    def test_indexing(self):
+        self._run_test("{l[0]}" , "a")
+        self._run_test("{a[6]}" , "w")
+
+    def test_slicing(self):
+        v = self.kwdict["a"]
+        self._run_test("{a[1:10]}"  , v[1:10])
+        self._run_test("{a[-10:-1]}", v[-10:-1])
+        self._run_test("{a[5:]}" , v[5:])
+        self._run_test("{a[50:]}", v[50:])
+        self._run_test("{a[:5]}" , v[:5])
+        self._run_test("{a[:50]}", v[:50])
+        self._run_test("{a[:]}"  , v)
+        self._run_test("{a[1:10:2]}"  , v[1:10:2])
+        self._run_test("{a[-10:-1:2]}", v[-10:-1:2])
+        self._run_test("{a[5::2]}" , v[5::2])
+        self._run_test("{a[50::2]}", v[50::2])
+        self._run_test("{a[:5:2]}" , v[:5:2])
+        self._run_test("{a[:50:2]}", v[:50:2])
+        self._run_test("{a[::]}"   , v)
+
+    def test_maxlen(self):
+        v = self.kwdict["a"]
+        self._run_test("{a:L5/foo/}" , "foo")
+        self._run_test("{a:L50/foo/}", v)
+        self._run_test("{a:L50/foo/>50}", " " * 39 + v)
+        self._run_test("{a:L50/foo/>51}", "foo")
+        self._run_test("{a:Lab/foo/}", "foo")
+
+    def test_join(self):
+        self._run_test("{l:J}"       , "abc")
+        self._run_test("{l:J,}"      , "a,b,c")
+        self._run_test("{l:J,/}"     , "a,b,c")
+        self._run_test("{l:J,/>20}"  , "               a,b,c")
+        self._run_test("{l:J - }"    , "a - b - c")
+        self._run_test("{l:J - /}"   , "a - b - c")
+        self._run_test("{l:J - />20}", "           a - b - c")
+
+        self._run_test("{a:J/}"      , self.kwdict["a"])
+        self._run_test("{a:J, /}"    , ", ".join(self.kwdict["a"]))
+
+    def test_replace(self):
+        self._run_test("{a:Rh/C/}"  , "CElLo wOrLd")
+        self._run_test("{a!l:Rh/C/}", "Cello world")
+        self._run_test("{a!u:Rh/C/}", "HELLO WORLD")
+
+        self._run_test("{a!l:Rl/_/}", "he__o wor_d")
+        self._run_test("{a!l:Rl//}" , "heo word")
+        self._run_test("{name:Rame/othing/}", "Nothing")
+
+    def test_chain_special(self):
+        # multiple replacements
+        self._run_test("{a:Rh/C/RE/e/RL/l/}", "Cello wOrld")
+        self._run_test("{d[b]!s:R1/Q/R2/A/R0/Y/}", "Y")
+
+        # join-and-replace
+        self._run_test("{l:J-/Rb/E/}", "a-E-c")
+
+        # optional-and-maxlen
+        self._run_test("{d[a]:?</>/L1/too long/}", "<too long>")
+        self._run_test("{d[c]:?</>/L5/too long/}", "")
+
+    def _run_test(self, format_string, result, default=None):
+        fmt = formatter.parse(format_string, default)
+        output = fmt.format_map(self.kwdict)
+        self.assertEqual(output, result, format_string)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_output.py b/test/test_output.py
new file mode 100644
index 0000000..84433f0
--- /dev/null
+++ b/test/test_output.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright 2021 Mike Fährmann
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from gallery_dl import output  # noqa E402
+
+
+class TestShorten(unittest.TestCase):
+
+    def test_shorten_noop(self, f=output.shorten_string):
+        self.assertEqual(f(""      , 10), "")
+        self.assertEqual(f("foobar", 10), "foobar")
+
+    def test_shorten(self, f=output.shorten_string):
+        s = "01234567890123456789"  # string of length 20
+        self.assertEqual(f(s, 30), s)
+        self.assertEqual(f(s, 25), s)
+        self.assertEqual(f(s, 20), s)
+        self.assertEqual(f(s, 19), "012345678…123456789")
+        self.assertEqual(f(s, 18), "01234567…123456789")
+        self.assertEqual(f(s, 17), "01234567…23456789")
+        self.assertEqual(f(s, 16), "0123456…23456789")
+        self.assertEqual(f(s, 15), "0123456…3456789")
+        self.assertEqual(f(s, 14), "012345…3456789")
+        self.assertEqual(f(s, 13), "012345…456789")
+        self.assertEqual(f(s, 12), "01234…456789")
+        self.assertEqual(f(s, 11), "01234…56789")
+        self.assertEqual(f(s, 10), "0123…56789")
+        self.assertEqual(f(s, 9) , "0123…6789")
+        self.assertEqual(f(s, 3) , "0…9")
+        self.assertEqual(f(s, 2) , "…9")
+
+    def test_shorten_separator(self, f=output.shorten_string):
+        s = "01234567890123456789"  # string of length 20
+        self.assertEqual(f(s, 20, "|---|"), s)
+        self.assertEqual(f(s, 19, "|---|"), "0123456|---|3456789")
+        self.assertEqual(f(s, 15, "|---|"), "01234|---|56789")
+        self.assertEqual(f(s, 10, "|---|"), "01|---|789")
+
+        self.assertEqual(f(s, 19, "..."), "01234567...23456789")
+        self.assertEqual(f(s, 19, "..") , "01234567..123456789")
+        self.assertEqual(f(s, 19, ".")  , "012345678.123456789")
+        self.assertEqual(f(s, 19, "")   , "0123456780123456789")
+
+
+class TestShortenEAW(unittest.TestCase):
+
+    def test_shorten_eaw_noop(self, f=output.shorten_string_eaw):
+        self.assertEqual(f(""      , 10), "")
+        self.assertEqual(f("foobar", 10), "foobar")
+
+    def test_shorten_eaw(self, f=output.shorten_string_eaw):
+        s = "01234567890123456789"  # 20 ascii characters
+        self.assertEqual(f(s, 30), s)
+        self.assertEqual(f(s, 25), s)
+        self.assertEqual(f(s, 20), s)
+        self.assertEqual(f(s, 19), "012345678…123456789")
+        self.assertEqual(f(s, 18), "01234567…123456789")
+        self.assertEqual(f(s, 17), "01234567…23456789")
+        self.assertEqual(f(s, 16), "0123456…23456789")
+        self.assertEqual(f(s, 15), "0123456…3456789")
+        self.assertEqual(f(s, 14), "012345…3456789")
+        self.assertEqual(f(s, 13), "012345…456789")
+        self.assertEqual(f(s, 12), "01234…456789")
+        self.assertEqual(f(s, 11), "01234…56789")
+        self.assertEqual(f(s, 10), "0123…56789")
+        self.assertEqual(f(s, 9) , "0123…6789")
+        self.assertEqual(f(s, 3) , "0…9")
+        self.assertEqual(f(s, 2) , "…9")
+
+    def test_shorten_eaw_wide(self, f=output.shorten_string_eaw):
+        s = "幻想郷幻想郷幻想郷幻想郷"  # 12 wide characters
+        self.assertEqual(f(s, 30), s)
+        self.assertEqual(f(s, 25), s)
+        self.assertEqual(f(s, 20), "幻想郷幻…想郷幻想郷")
+        self.assertEqual(f(s, 19), "幻想郷幻…想郷幻想郷")
+        self.assertEqual(f(s, 18), "幻想郷幻…郷幻想郷")
+        self.assertEqual(f(s, 17), "幻想郷幻…郷幻想郷")
+        self.assertEqual(f(s, 16), "幻想郷…郷幻想郷")
+        self.assertEqual(f(s, 15), "幻想郷…郷幻想郷")
+        self.assertEqual(f(s, 14), "幻想郷…幻想郷")
+        self.assertEqual(f(s, 13), "幻想郷…幻想郷")
+        self.assertEqual(f(s, 12), "幻想…幻想郷")
+        self.assertEqual(f(s, 11), "幻想…幻想郷")
+        self.assertEqual(f(s, 10), "幻想…想郷")
+        self.assertEqual(f(s, 9) , "幻想…想郷")
+        self.assertEqual(f(s, 3) , "…郷")
+
+    def test_shorten_eaw_mix(self, f=output.shorten_string_eaw):
+        s = "幻-想-郷##幻-想-郷##幻-想-郷"  # mixed characters
+        self.assertEqual(f(s, 28), s)
+        self.assertEqual(f(s, 25), "幻-想-郷##幻…郷##幻-想-郷")
+
+        self.assertEqual(f(s, 20), "幻-想-郷#…##幻-想-郷")
+        self.assertEqual(f(s, 19), "幻-想-郷#…#幻-想-郷")
+        self.assertEqual(f(s, 18), "幻-想-郷…#幻-想-郷")
+        self.assertEqual(f(s, 17), "幻-想-郷…幻-想-郷")
+        self.assertEqual(f(s, 16), "幻-想-…#幻-想-郷")
+        self.assertEqual(f(s, 15), "幻-想-…幻-想-郷")
+        self.assertEqual(f(s, 14), "幻-想-…-想-郷")
+        self.assertEqual(f(s, 13), "幻-想-…-想-郷")
+        self.assertEqual(f(s, 12), "幻-想…-想-郷")
+        self.assertEqual(f(s, 11), "幻-想…想-郷")
+        self.assertEqual(f(s, 10), "幻-…-想-郷")
+        self.assertEqual(f(s, 9) , "幻-…想-郷")
+        self.assertEqual(f(s, 3) , "…郷")
+
+    def test_shorten_eaw_separator(self, f=output.shorten_string_eaw):
+        s = "01234567890123456789"  # 20 ascii characters
+        self.assertEqual(f(s, 20, "|---|"), s)
+        self.assertEqual(f(s, 19, "|---|"), "0123456|---|3456789")
+        self.assertEqual(f(s, 15, "|---|"), "01234|---|56789")
+        self.assertEqual(f(s, 10, "|---|"), "01|---|789")
+
+        self.assertEqual(f(s, 19, "..."), "01234567...23456789")
+        self.assertEqual(f(s, 19, "..") , "01234567..123456789")
+        self.assertEqual(f(s, 19, ".")  , "012345678.123456789")
+        self.assertEqual(f(s, 19, "")   , "0123456780123456789")
+
+    def test_shorten_eaw_separator_wide(self, f=output.shorten_string_eaw):
+        s = "幻想郷幻想郷幻想郷幻想郷"  # 12 wide characters
+        self.assertEqual(f(s, 24, "|---|"), s)
+        self.assertEqual(f(s, 19, "|---|"), "幻想郷|---|郷幻想郷")
+        self.assertEqual(f(s, 15, "|---|"), "幻想|---|幻想郷")
+        self.assertEqual(f(s, 10, "|---|"), "幻|---|郷")
+
+        self.assertEqual(f(s, 19, "..."), "幻想郷幻...郷幻想郷")
+        self.assertEqual(f(s, 19, "..") , "幻想郷幻..郷幻想郷")
+        self.assertEqual(f(s, 19, ".")  , "幻想郷幻.想郷幻想郷")
+        self.assertEqual(f(s, 19, "")   , "幻想郷幻想郷幻想郷")
+
+    def test_shorten_eaw_separator_mix_(self, f=output.shorten_string_eaw):
+        s = "幻-想-郷##幻-想-郷##幻-想-郷"  # mixed characters
+        self.assertEqual(f(s, 30, "|---|"), s)
+        self.assertEqual(f(s, 19, "|---|"), "幻-想-|---|幻-想-郷")
+        self.assertEqual(f(s, 15, "|---|"), "幻-想|---|想-郷")
+        self.assertEqual(f(s, 10, "|---|"), "幻|---|-郷")
+
+        self.assertEqual(f(s, 19, "..."), "幻-想-郷...幻-想-郷")
+        self.assertEqual(f(s, 19, "..") , "幻-想-郷..#幻-想-郷")
+        self.assertEqual(f(s, 19, ".")  , "幻-想-郷#.#幻-想-郷")
+        self.assertEqual(f(s, 19, "")   , "幻-想-郷###幻-想-郷")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_postprocessor.py b/test/test_postprocessor.py
index 00c17b2..84d2747 100644
--- a/test/test_postprocessor.py
+++ b/test/test_postprocessor.py
@@ -19,7 +19,7 @@ import collections
 from datetime import datetime, timezone as tz
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from gallery_dl import extractor, output, util  # noqa E402
+from gallery_dl import extractor, output, path  # noqa E402
 from gallery_dl import postprocessor, config  # noqa E402
 from gallery_dl.postprocessor.common import PostProcessor  # noqa E402
 
@@ -32,7 +32,7 @@ class FakeJob():
 
     def __init__(self, extr=extractor.find("test:")):
         self.extractor = extr
-        self.pathfmt = util.PathFormat(extr)
+        self.pathfmt = path.PathFormat(extr)
         self.out = output.NullOutput()
         self.get_logger = logging.getLogger
         self.hooks = collections.defaultdict(list)
diff --git a/test/test_results.py b/test/test_results.py
index 8a20e6b..ba1e0b1 100644
--- a/test/test_results.py
+++ b/test/test_results.py
@@ -17,7 +17,8 @@ import hashlib
 import datetime
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from gallery_dl import extractor, util, job, config, exception  # noqa E402
+from gallery_dl import \
+    extractor, util, job, config, exception, formatter  # noqa E402
 
 
 # temporary issues, etc.
@@ -91,6 +92,8 @@ class TestExtractorResults(unittest.TestCase):
             for url, kwdict in zip(tjob.url_list, tjob.kwdict_list):
                 if "_extractor" in kwdict:
                     extr = kwdict["_extractor"].from_url(url)
+                    if extr is None and not result.get("extractor", True):
+                        continue
                     self.assertIsInstance(extr, kwdict["_extractor"])
                     self.assertEqual(extr.url, url)
         else:
@@ -260,14 +263,14 @@ class TestPathfmt():
         return 0
 
 
-class TestFormatter(util.Formatter):
+class TestFormatter(formatter.StringFormatter):
 
     @staticmethod
     def _noop(_):
         return ""
 
     def _apply_simple(self, key, fmt):
-        if key == "extension" or "._parse_optional." in repr(fmt):
+        if key == "extension" or "_parse_optional." in repr(fmt):
             return self._noop
 
         def wrap(obj):
@@ -275,7 +278,7 @@ class TestFormatter(util.Formatter):
         return wrap
 
     def _apply(self, key, funcs, fmt):
-        if key == "extension" or "._parse_optional." in repr(fmt):
+        if key == "extension" or "_parse_optional." in repr(fmt):
             return self._noop
 
         def wrap(obj):
diff --git a/test/test_util.py b/test/test_util.py
index 1aa66d1..0fbbbce 100644
--- a/test/test_util.py
+++ b/test/test_util.py
@@ -260,169 +260,6 @@ class TestCookiesTxt(unittest.TestCase):
         )
 
 
-class TestFormatter(unittest.TestCase):
-
-    kwdict = {
-        "a": "hElLo wOrLd",
-        "b": "äöü",
-        "d": {"a": "foo", "b": 0, "c": None},
-        "l": ["a", "b", "c"],
-        "n": None,
-        "s": " \n\r\tSPACE    ",
-        "u": "%27%3C%20/%20%3E%27",
-        "t": 1262304000,
-        "dt": datetime.datetime(2010, 1, 1),
-        "name": "Name",
-        "title1": "Title",
-        "title2": "",
-        "title3": None,
-        "title4": 0,
-    }
-
-    def test_conversions(self):
-        self._run_test("{a!l}", "hello world")
-        self._run_test("{a!u}", "HELLO WORLD")
-        self._run_test("{a!c}", "Hello world")
-        self._run_test("{a!C}", "Hello World")
-        self._run_test("{s!t}", "SPACE")
-        self._run_test("{a!U}", self.kwdict["a"])
-        self._run_test("{u!U}", "'< / >'")
-        self._run_test("{a!s}", self.kwdict["a"])
-        self._run_test("{a!r}", "'" + self.kwdict["a"] + "'")
-        self._run_test("{a!a}", "'" + self.kwdict["a"] + "'")
-        self._run_test("{b!a}", "'\\xe4\\xf6\\xfc'")
-        self._run_test("{a!S}", self.kwdict["a"])
-        self._run_test("{l!S}", "a, b, c")
-        self._run_test("{n!S}", "")
-        self._run_test("{t!d}", datetime.datetime(2010, 1, 1))
-        self._run_test("{t!d:%Y-%m-%d}", "2010-01-01")
-        self._run_test("{dt!T}", "1262304000")
-        self._run_test("{l!j}", '["a", "b", "c"]')
-
-        with self.assertRaises(KeyError):
-            self._run_test("{a!q}", "hello world")
-
-    def test_optional(self):
-        self._run_test("{name}{title1}", "NameTitle")
-        self._run_test("{name}{title1:?//}", "NameTitle")
-        self._run_test("{name}{title1:? **/''/}", "Name **Title''")
-
-        self._run_test("{name}{title2}", "Name")
-        self._run_test("{name}{title2:?//}", "Name")
-        self._run_test("{name}{title2:? **/''/}", "Name")
-
-        self._run_test("{name}{title3}", "NameNone")
-        self._run_test("{name}{title3:?//}", "Name")
-        self._run_test("{name}{title3:? **/''/}", "Name")
-
-        self._run_test("{name}{title4}", "Name0")
-        self._run_test("{name}{title4:?//}", "Name")
-        self._run_test("{name}{title4:? **/''/}", "Name")
-
-    def test_missing(self):
-        replacement = "None"
-
-        self._run_test("{missing}", replacement)
-        self._run_test("{missing.attr}", replacement)
-        self._run_test("{missing[key]}", replacement)
-        self._run_test("{missing:?a//}", "")
-
-        self._run_test("{name[missing]}", replacement)
-        self._run_test("{name[missing].attr}", replacement)
-        self._run_test("{name[missing][key]}", replacement)
-        self._run_test("{name[missing]:?a//}", "")
-
-    def test_missing_custom_default(self):
-        replacement = default = "foobar"
-        self._run_test("{missing}"     , replacement, default)
-        self._run_test("{missing.attr}", replacement, default)
-        self._run_test("{missing[key]}", replacement, default)
-        self._run_test("{missing:?a//}", "a" + default, default)
-
-    def test_alternative(self):
-        self._run_test("{a|z}"    , "hElLo wOrLd")
-        self._run_test("{z|a}"    , "hElLo wOrLd")
-        self._run_test("{z|y|a}"  , "hElLo wOrLd")
-        self._run_test("{z|y|x|a}", "hElLo wOrLd")
-        self._run_test("{z|n|a|y}", "hElLo wOrLd")
-
-        self._run_test("{z|a!C}"      , "Hello World")
-        self._run_test("{z|a:Rh/C/}"  , "CElLo wOrLd")
-        self._run_test("{z|a!C:RH/C/}", "Cello World")
-        self._run_test("{z|y|x:?</>/}", "")
-
-        self._run_test("{d[c]|d[b]|d[a]}", "foo")
-        self._run_test("{d[a]|d[b]|d[c]}", "foo")
-        self._run_test("{d[z]|d[y]|d[x]}", "None")
-
-    def test_indexing(self):
-        self._run_test("{l[0]}" , "a")
-        self._run_test("{a[6]}" , "w")
-
-    def test_slicing(self):
-        v = self.kwdict["a"]
-        self._run_test("{a[1:10]}"  , v[1:10])
-        self._run_test("{a[-10:-1]}", v[-10:-1])
-        self._run_test("{a[5:]}" , v[5:])
-        self._run_test("{a[50:]}", v[50:])
-        self._run_test("{a[:5]}" , v[:5])
-        self._run_test("{a[:50]}", v[:50])
-        self._run_test("{a[:]}"  , v)
-        self._run_test("{a[1:10:2]}"  , v[1:10:2])
-        self._run_test("{a[-10:-1:2]}", v[-10:-1:2])
-        self._run_test("{a[5::2]}" , v[5::2])
-        self._run_test("{a[50::2]}", v[50::2])
-        self._run_test("{a[:5:2]}" , v[:5:2])
-        self._run_test("{a[:50:2]}", v[:50:2])
-        self._run_test("{a[::]}"   , v)
-
-    def test_maxlen(self):
-        v = self.kwdict["a"]
-        self._run_test("{a:L5/foo/}" , "foo")
-        self._run_test("{a:L50/foo/}", v)
-        self._run_test("{a:L50/foo/>50}", " " * 39 + v)
-        self._run_test("{a:L50/foo/>51}", "foo")
-        self._run_test("{a:Lab/foo/}", "foo")
-
-    def test_join(self):
-        self._run_test("{l:J}"       , "abc")
-        self._run_test("{l:J,}"      , "a,b,c")
-        self._run_test("{l:J,/}"     , "a,b,c")
-        self._run_test("{l:J,/>20}"  , "               a,b,c")
-        self._run_test("{l:J - }"    , "a - b - c")
-        self._run_test("{l:J - /}"   , "a - b - c")
-        self._run_test("{l:J - />20}", "           a - b - c")
-
-        self._run_test("{a:J/}"      , self.kwdict["a"])
-        self._run_test("{a:J, /}"    , ", ".join(self.kwdict["a"]))
-
-    def test_replace(self):
-        self._run_test("{a:Rh/C/}"  , "CElLo wOrLd")
-        self._run_test("{a!l:Rh/C/}", "Cello world")
-        self._run_test("{a!u:Rh/C/}", "HELLO WORLD")
-
-        self._run_test("{a!l:Rl/_/}", "he__o wor_d")
-        self._run_test("{a!l:Rl//}" , "heo word")
-        self._run_test("{name:Rame/othing/}", "Nothing")
-
-    def test_chain_special(self):
-        # multiple replacements
-        self._run_test("{a:Rh/C/RE/e/RL/l/}", "Cello wOrld")
-        self._run_test("{d[b]!s:R1/Q/R2/A/R0/Y/}", "Y")
-
-        # join-and-replace
-        self._run_test("{l:J-/Rb/E/}", "a-E-c")
-
-        # optional-and-maxlen
-        self._run_test("{d[a]:?</>/L1/too long/}", "<too long>")
-        self._run_test("{d[c]:?</>/L5/too long/}", "")
-
-    def _run_test(self, format_string, result, default=None):
-        formatter = util.Formatter(format_string, default)
-        output = formatter.format_map(self.kwdict)
-        self.assertEqual(output, result, format_string)
-
-
 class TestOther(unittest.TestCase):
 
     def test_bencode(self):
@@ -534,20 +371,17 @@ class TestOther(unittest.TestCase):
         self.assertRegex(token, r"^[0-9a-f]+$")
 
     def test_format_value(self):
-        self.assertEqual(util.format_value(0)         , "0B")
-        self.assertEqual(util.format_value(1)         , "1B")
-        self.assertEqual(util.format_value(12)        , "12B")
-        self.assertEqual(util.format_value(123)       , "123B")
-        self.assertEqual(util.format_value(1234)      , "1.23kB")
-        self.assertEqual(util.format_value(12345)     , "12.34kB")
-        self.assertEqual(util.format_value(123456)    , "123.45kB")
-        self.assertEqual(util.format_value(1234567)   , "1.23MB")
-        self.assertEqual(util.format_value(12345678)  , "12.34MB")
-        self.assertEqual(util.format_value(123456789) , "123.45MB")
-        self.assertEqual(util.format_value(1234567890), "1.23GB")
-
-        self.assertEqual(util.format_value(123   , "B/s"), "123B/s")
-        self.assertEqual(util.format_value(123456, "B/s"), "123.45kB/s")
+        self.assertEqual(util.format_value(0)         , "0")
+        self.assertEqual(util.format_value(1)         , "1")
+        self.assertEqual(util.format_value(12)        , "12")
+        self.assertEqual(util.format_value(123)       , "123")
+        self.assertEqual(util.format_value(1234)      , "1.23k")
+        self.assertEqual(util.format_value(12345)     , "12.34k")
+        self.assertEqual(util.format_value(123456)    , "123.45k")
+        self.assertEqual(util.format_value(1234567)   , "1.23M")
+        self.assertEqual(util.format_value(12345678)  , "12.34M")
+        self.assertEqual(util.format_value(123456789) , "123.45M")
+        self.assertEqual(util.format_value(1234567890), "1.23G")
 
     def test_combine_dict(self):
         self.assertEqual(