ytdl-org
/
youtube-dl
1
0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 1077 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
17771 Commits
9 Ramas
53MB
Árbol: 4eda10499e
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '4eda10499e'
${ noResults }
youtube-dl/test/test_utils.py

1449 líneas
66KB
Original Blame Histórico 

  1. #!/usr/bin/env python

  2. # coding: utf-8

  3. 

  4. from __future__ import unicode_literals

  5. 

  6. # Allow direct execution

  7. import os

  8. import sys

  9. import unittest

  10. sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

  11. 

  12. 

  13. # Various small unit tests

  14. import io

  15. import json

  16. import xml.etree.ElementTree

  17. 

  18. from youtube_dl.utils import (

  19.     age_restricted,

  20.     args_to_str,

  21.     encode_base_n,

  22.     caesar,

  23.     clean_html,

  24.     date_from_str,

  25.     DateRange,

  26.     detect_exe_version,

  27.     determine_ext,

  28.     dict_get,

  29.     encode_compat_str,

  30.     encodeFilename,

  31.     escape_rfc3986,

  32.     escape_url,

  33.     extract_attributes,

  34.     ExtractorError,

  35.     find_xpath_attr,

  36.     fix_xml_ampersands,

  37.     float_or_none,

  38.     get_element_by_class,

  39.     get_element_by_attribute,

  40.     get_elements_by_class,

  41.     get_elements_by_attribute,

  42.     InAdvancePagedList,

  43.     int_or_none,

  44.     intlist_to_bytes,

  45.     is_html,

  46.     js_to_json,

  47.     limit_length,

  48.     merge_dicts,

  49.     mimetype2ext,

  50.     month_by_name,

  51.     multipart_encode,

  52.     ohdave_rsa_encrypt,

  53.     OnDemandPagedList,

  54.     orderedSet,

  55.     parse_age_limit,

  56.     parse_duration,

  57.     parse_filesize,

  58.     parse_count,

  59.     parse_iso8601,

  60.     parse_resolution,

  61.     parse_bitrate,

  62.     pkcs1pad,

  63.     read_batch_urls,

  64.     sanitize_filename,

  65.     sanitize_path,

  66.     sanitize_url,

  67.     expand_path,

  68.     prepend_extension,

  69.     replace_extension,

  70.     remove_start,

  71.     remove_end,

  72.     remove_quotes,

  73.     rot47,

  74.     shell_quote,

  75.     smuggle_url,

  76.     str_to_int,

  77.     strip_jsonp,

  78.     strip_or_none,

  79.     subtitles_filename,

  80.     timeconvert,

  81.     unescapeHTML,

  82.     unified_strdate,

  83.     unified_timestamp,

  84.     unsmuggle_url,

  85.     uppercase_escape,

  86.     lowercase_escape,

  87.     url_basename,

  88.     url_or_none,

  89.     base_url,

  90.     urljoin,

  91.     urlencode_postdata,

  92.     urshift,

  93.     update_url_query,

  94.     version_tuple,

  95.     xpath_with_ns,

  96.     xpath_element,

  97.     xpath_text,

  98.     xpath_attr,

  99.     render_table,

  100.     match_str,

  101.     parse_dfxp_time_expr,

  102.     dfxp2srt,

  103.     cli_option,

  104.     cli_valueless_option,

  105.     cli_bool_option,

  106.     parse_codecs,

  107. )

  108. from youtube_dl.compat import (

  109.     compat_chr,

  110.     compat_etree_fromstring,

  111.     compat_getenv,

  112.     compat_os_name,

  113.     compat_setenv,

  114.     compat_urlparse,

  115.     compat_parse_qs,

  116. )

  117. 

  118. 

  119. class TestUtil(unittest.TestCase):

  120.     def test_timeconvert(self):

  121.         self.assertTrue(timeconvert('') is None)

  122.         self.assertTrue(timeconvert('bougrg') is None)

  123. 

  124.     def test_sanitize_filename(self):

  125.         self.assertEqual(sanitize_filename('abc'), 'abc')

  126.         self.assertEqual(sanitize_filename('abc_d-e'), 'abc_d-e')

  127. 

  128.         self.assertEqual(sanitize_filename('123'), '123')

  129. 

  130.         self.assertEqual('abc_de', sanitize_filename('abc/de'))

  131.         self.assertFalse('/' in sanitize_filename('abc/de///'))

  132. 

  133.         self.assertEqual('abc_de', sanitize_filename('abc/<>\\*|de'))

  134.         self.assertEqual('xxx', sanitize_filename('xxx/<>\\*|'))

  135.         self.assertEqual('yes no', sanitize_filename('yes? no'))

  136.         self.assertEqual('this - that', sanitize_filename('this: that'))

  137. 

  138.         self.assertEqual(sanitize_filename('AT&T'), 'AT&T')

  139.         aumlaut = 'ä'

  140.         self.assertEqual(sanitize_filename(aumlaut), aumlaut)

  141.         tests = '\u043a\u0438\u0440\u0438\u043b\u043b\u0438\u0446\u0430'

  142.         self.assertEqual(sanitize_filename(tests), tests)

  143. 

  144.         self.assertEqual(

  145.             sanitize_filename('New World record at 0:12:34'),

  146.             'New World record at 0_12_34')

  147. 

  148.         self.assertEqual(sanitize_filename('--gasdgf'), '_-gasdgf')

  149.         self.assertEqual(sanitize_filename('--gasdgf', is_id=True), '--gasdgf')

  150.         self.assertEqual(sanitize_filename('.gasdgf'), 'gasdgf')

  151.         self.assertEqual(sanitize_filename('.gasdgf', is_id=True), '.gasdgf')

  152. 

  153.         forbidden = '"\0\\/'

  154.         for fc in forbidden:

  155.             for fbc in forbidden:

  156.                 self.assertTrue(fbc not in sanitize_filename(fc))

  157. 

  158.     def test_sanitize_filename_restricted(self):

  159.         self.assertEqual(sanitize_filename('abc', restricted=True), 'abc')

  160.         self.assertEqual(sanitize_filename('abc_d-e', restricted=True), 'abc_d-e')

  161. 

  162.         self.assertEqual(sanitize_filename('123', restricted=True), '123')

  163. 

  164.         self.assertEqual('abc_de', sanitize_filename('abc/de', restricted=True))

  165.         self.assertFalse('/' in sanitize_filename('abc/de///', restricted=True))

  166. 

  167.         self.assertEqual('abc_de', sanitize_filename('abc/<>\\*|de', restricted=True))

  168.         self.assertEqual('xxx', sanitize_filename('xxx/<>\\*|', restricted=True))

  169.         self.assertEqual('yes_no', sanitize_filename('yes? no', restricted=True))

  170.         self.assertEqual('this_-_that', sanitize_filename('this: that', restricted=True))

  171. 

  172.         tests = 'aäb\u4e2d\u56fd\u7684c'

  173.         self.assertEqual(sanitize_filename(tests, restricted=True), 'aab_c')

  174.         self.assertTrue(sanitize_filename('\xf6', restricted=True) != '')  # No empty filename

  175. 

  176.         forbidden = '"\0\\/&!: \'\t\n()[]{}$;`^,#'

  177.         for fc in forbidden:

  178.             for fbc in forbidden:

  179.                 self.assertTrue(fbc not in sanitize_filename(fc, restricted=True))

  180. 

  181.         # Handle a common case more neatly

  182.         self.assertEqual(sanitize_filename('\u5927\u58f0\u5e26 - Song', restricted=True), 'Song')

  183.         self.assertEqual(sanitize_filename('\u603b\u7edf: Speech', restricted=True), 'Speech')

  184.         # .. but make sure the file name is never empty

  185.         self.assertTrue(sanitize_filename('-', restricted=True) != '')

  186.         self.assertTrue(sanitize_filename(':', restricted=True) != '')

  187. 

  188.         self.assertEqual(sanitize_filename(

  189.             'ÂÃÄÀÁÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖŐØŒÙÚÛÜŰÝÞßàáâãäåæçèéêëìíîïðñòóôõöőøœùúûüűýþÿ', restricted=True),

  190.             'AAAAAAAECEEEEIIIIDNOOOOOOOOEUUUUUYTHssaaaaaaaeceeeeiiiionooooooooeuuuuuythy')

  191. 

  192.     def test_sanitize_ids(self):

  193.         self.assertEqual(sanitize_filename('_n_cd26wFpw', is_id=True), '_n_cd26wFpw')

  194.         self.assertEqual(sanitize_filename('_BD_eEpuzXw', is_id=True), '_BD_eEpuzXw')

  195.         self.assertEqual(sanitize_filename('N0Y__7-UOdI', is_id=True), 'N0Y__7-UOdI')

  196. 

  197.     def test_sanitize_path(self):

  198.         if sys.platform != 'win32':

  199.             return

  200. 

  201.         self.assertEqual(sanitize_path('abc'), 'abc')

  202.         self.assertEqual(sanitize_path('abc/def'), 'abc\\def')

  203.         self.assertEqual(sanitize_path('abc\\def'), 'abc\\def')

  204.         self.assertEqual(sanitize_path('abc|def'), 'abc#def')

  205.         self.assertEqual(sanitize_path('<>:"|?*'), '#######')

  206.         self.assertEqual(sanitize_path('C:/abc/def'), 'C:\\abc\\def')

  207.         self.assertEqual(sanitize_path('C?:/abc/def'), 'C##\\abc\\def')

  208. 

  209.         self.assertEqual(sanitize_path('\\\\?\\UNC\\ComputerName\\abc'), '\\\\?\\UNC\\ComputerName\\abc')

  210.         self.assertEqual(sanitize_path('\\\\?\\UNC/ComputerName/abc'), '\\\\?\\UNC\\ComputerName\\abc')

  211. 

  212.         self.assertEqual(sanitize_path('\\\\?\\C:\\abc'), '\\\\?\\C:\\abc')

  213.         self.assertEqual(sanitize_path('\\\\?\\C:/abc'), '\\\\?\\C:\\abc')

  214.         self.assertEqual(sanitize_path('\\\\?\\C:\\ab?c\\de:f'), '\\\\?\\C:\\ab#c\\de#f')

  215.         self.assertEqual(sanitize_path('\\\\?\\C:\\abc'), '\\\\?\\C:\\abc')

  216. 

  217.         self.assertEqual(

  218.             sanitize_path('youtube/%(uploader)s/%(autonumber)s-%(title)s-%(upload_date)s.%(ext)s'),

  219.             'youtube\\%(uploader)s\\%(autonumber)s-%(title)s-%(upload_date)s.%(ext)s')

  220. 

  221.         self.assertEqual(

  222.             sanitize_path('youtube/TheWreckingYard ./00001-Not bad, Especially for Free! (1987 Yamaha 700)-20141116.mp4.part'),

  223.             'youtube\\TheWreckingYard #\\00001-Not bad, Especially for Free! (1987 Yamaha 700)-20141116.mp4.part')

  224.         self.assertEqual(sanitize_path('abc/def...'), 'abc\\def..#')

  225.         self.assertEqual(sanitize_path('abc.../def'), 'abc..#\\def')

  226.         self.assertEqual(sanitize_path('abc.../def...'), 'abc..#\\def..#')

  227. 

  228.         self.assertEqual(sanitize_path('../abc'), '..\\abc')

  229.         self.assertEqual(sanitize_path('../../abc'), '..\\..\\abc')

  230.         self.assertEqual(sanitize_path('./abc'), 'abc')

  231.         self.assertEqual(sanitize_path('./../abc'), '..\\abc')

  232. 

  233.     def test_sanitize_url(self):

  234.         self.assertEqual(sanitize_url('//foo.bar'), 'http://foo.bar')

  235.         self.assertEqual(sanitize_url('httpss://foo.bar'), 'https://foo.bar')

  236.         self.assertEqual(sanitize_url('rmtps://foo.bar'), 'rtmps://foo.bar')

  237.         self.assertEqual(sanitize_url('https://foo.bar'), 'https://foo.bar')

  238. 

  239.     def test_expand_path(self):

  240.         def env(var):

  241.             return '%{0}%'.format(var) if sys.platform == 'win32' else '${0}'.format(var)

  242. 

  243.         compat_setenv('YOUTUBE_DL_EXPATH_PATH', 'expanded')

  244.         self.assertEqual(expand_path(env('YOUTUBE_DL_EXPATH_PATH')), 'expanded')

  245.         self.assertEqual(expand_path(env('HOME')), compat_getenv('HOME'))

  246.         self.assertEqual(expand_path('~'), compat_getenv('HOME'))

  247.         self.assertEqual(

  248.             expand_path('~/%s' % env('YOUTUBE_DL_EXPATH_PATH')),

  249.             '%s/expanded' % compat_getenv('HOME'))

  250. 

  251.     def test_prepend_extension(self):

  252.         self.assertEqual(prepend_extension('abc.ext', 'temp'), 'abc.temp.ext')

  253.         self.assertEqual(prepend_extension('abc.ext', 'temp', 'ext'), 'abc.temp.ext')

  254.         self.assertEqual(prepend_extension('abc.unexpected_ext', 'temp', 'ext'), 'abc.unexpected_ext.temp')

  255.         self.assertEqual(prepend_extension('abc', 'temp'), 'abc.temp')

  256.         self.assertEqual(prepend_extension('.abc', 'temp'), '.abc.temp')

  257.         self.assertEqual(prepend_extension('.abc.ext', 'temp'), '.abc.temp.ext')

  258. 

  259.     def test_replace_extension(self):

  260.         self.assertEqual(replace_extension('abc.ext', 'temp'), 'abc.temp')

  261.         self.assertEqual(replace_extension('abc.ext', 'temp', 'ext'), 'abc.temp')

  262.         self.assertEqual(replace_extension('abc.unexpected_ext', 'temp', 'ext'), 'abc.unexpected_ext.temp')

  263.         self.assertEqual(replace_extension('abc', 'temp'), 'abc.temp')

  264.         self.assertEqual(replace_extension('.abc', 'temp'), '.abc.temp')

  265.         self.assertEqual(replace_extension('.abc.ext', 'temp'), '.abc.temp')

  266. 

  267.     def test_subtitles_filename(self):

  268.         self.assertEqual(subtitles_filename('abc.ext', 'en', 'vtt'), 'abc.en.vtt')

  269.         self.assertEqual(subtitles_filename('abc.ext', 'en', 'vtt', 'ext'), 'abc.en.vtt')

  270.         self.assertEqual(subtitles_filename('abc.unexpected_ext', 'en', 'vtt', 'ext'), 'abc.unexpected_ext.en.vtt')

  271. 

  272.     def test_remove_start(self):

  273.         self.assertEqual(remove_start(None, 'A - '), None)

  274.         self.assertEqual(remove_start('A - B', 'A - '), 'B')

  275.         self.assertEqual(remove_start('B - A', 'A - '), 'B - A')

  276. 

  277.     def test_remove_end(self):

  278.         self.assertEqual(remove_end(None, ' - B'), None)

  279.         self.assertEqual(remove_end('A - B', ' - B'), 'A')

  280.         self.assertEqual(remove_end('B - A', ' - B'), 'B - A')

  281. 

  282.     def test_remove_quotes(self):

  283.         self.assertEqual(remove_quotes(None), None)

  284.         self.assertEqual(remove_quotes('"'), '"')

  285.         self.assertEqual(remove_quotes("'"), "'")

  286.         self.assertEqual(remove_quotes(';'), ';')

  287.         self.assertEqual(remove_quotes('";'), '";')

  288.         self.assertEqual(remove_quotes('""'), '')

  289.         self.assertEqual(remove_quotes('";"'), ';')

  290. 

  291.     def test_ordered_set(self):

  292.         self.assertEqual(orderedSet([1, 1, 2, 3, 4, 4, 5, 6, 7, 3, 5]), [1, 2, 3, 4, 5, 6, 7])

  293.         self.assertEqual(orderedSet([]), [])

  294.         self.assertEqual(orderedSet([1]), [1])

  295.         # keep the list ordered

  296.         self.assertEqual(orderedSet([135, 1, 1, 1]), [135, 1])

  297. 

  298.     def test_unescape_html(self):

  299.         self.assertEqual(unescapeHTML('%20;'), '%20;')

  300.         self.assertEqual(unescapeHTML('&#x2F;'), '/')

  301.         self.assertEqual(unescapeHTML('&#47;'), '/')

  302.         self.assertEqual(unescapeHTML('&eacute;'), 'é')

  303.         self.assertEqual(unescapeHTML('&#2013266066;'), '&#2013266066;')

  304.         self.assertEqual(unescapeHTML('&a&quot;'), '&a"')

  305.         # HTML5 entities

  306.         self.assertEqual(unescapeHTML('&period;&apos;'), '.\'')

  307. 

  308.     def test_date_from_str(self):

  309.         self.assertEqual(date_from_str('yesterday'), date_from_str('now-1day'))

  310.         self.assertEqual(date_from_str('now+7day'), date_from_str('now+1week'))

  311.         self.assertEqual(date_from_str('now+14day'), date_from_str('now+2week'))

  312.         self.assertEqual(date_from_str('now+365day'), date_from_str('now+1year'))

  313.         self.assertEqual(date_from_str('now+30day'), date_from_str('now+1month'))

  314. 

  315.     def test_daterange(self):

  316.         _20century = DateRange("19000101", "20000101")

  317.         self.assertFalse("17890714" in _20century)

  318.         _ac = DateRange("00010101")

  319.         self.assertTrue("19690721" in _ac)

  320.         _firstmilenium = DateRange(end="10000101")

  321.         self.assertTrue("07110427" in _firstmilenium)

  322. 

  323.     def test_unified_dates(self):

  324.         self.assertEqual(unified_strdate('December 21, 2010'), '20101221')

  325.         self.assertEqual(unified_strdate('8/7/2009'), '20090708')

  326.         self.assertEqual(unified_strdate('Dec 14, 2012'), '20121214')

  327.         self.assertEqual(unified_strdate('2012/10/11 01:56:38 +0000'), '20121011')

  328.         self.assertEqual(unified_strdate('1968 12 10'), '19681210')

  329.         self.assertEqual(unified_strdate('1968-12-10'), '19681210')

  330.         self.assertEqual(unified_strdate('28/01/2014 21:00:00 +0100'), '20140128')

  331.         self.assertEqual(

  332.             unified_strdate('11/26/2014 11:30:00 AM PST', day_first=False),

  333.             '20141126')

  334.         self.assertEqual(

  335.             unified_strdate('2/2/2015 6:47:40 PM', day_first=False),

  336.             '20150202')

  337.         self.assertEqual(unified_strdate('Feb 14th 2016 5:45PM'), '20160214')

  338.         self.assertEqual(unified_strdate('25-09-2014'), '20140925')

  339.         self.assertEqual(unified_strdate('27.02.2016 17:30'), '20160227')

  340.         self.assertEqual(unified_strdate('UNKNOWN DATE FORMAT'), None)

  341.         self.assertEqual(unified_strdate('Feb 7, 2016 at 6:35 pm'), '20160207')

  342.         self.assertEqual(unified_strdate('July 15th, 2013'), '20130715')

  343.         self.assertEqual(unified_strdate('September 1st, 2013'), '20130901')

  344.         self.assertEqual(unified_strdate('Sep 2nd, 2013'), '20130902')

  345.         self.assertEqual(unified_strdate('November 3rd, 2019'), '20191103')

  346.         self.assertEqual(unified_strdate('October 23rd, 2005'), '20051023')

  347. 

  348.     def test_unified_timestamps(self):

  349.         self.assertEqual(unified_timestamp('December 21, 2010'), 1292889600)

  350.         self.assertEqual(unified_timestamp('8/7/2009'), 1247011200)

  351.         self.assertEqual(unified_timestamp('Dec 14, 2012'), 1355443200)

  352.         self.assertEqual(unified_timestamp('2012/10/11 01:56:38 +0000'), 1349920598)

  353.         self.assertEqual(unified_timestamp('1968 12 10'), -33436800)

  354.         self.assertEqual(unified_timestamp('1968-12-10'), -33436800)

  355.         self.assertEqual(unified_timestamp('28/01/2014 21:00:00 +0100'), 1390939200)

  356.         self.assertEqual(

  357.             unified_timestamp('11/26/2014 11:30:00 AM PST', day_first=False),

  358.             1417001400)

  359.         self.assertEqual(

  360.             unified_timestamp('2/2/2015 6:47:40 PM', day_first=False),

  361.             1422902860)

  362.         self.assertEqual(unified_timestamp('Feb 14th 2016 5:45PM'), 1455471900)

  363.         self.assertEqual(unified_timestamp('25-09-2014'), 1411603200)

  364.         self.assertEqual(unified_timestamp('27.02.2016 17:30'), 1456594200)

  365.         self.assertEqual(unified_timestamp('UNKNOWN DATE FORMAT'), None)

  366.         self.assertEqual(unified_timestamp('May 16, 2016 11:15 PM'), 1463440500)

  367.         self.assertEqual(unified_timestamp('Feb 7, 2016 at 6:35 pm'), 1454870100)

  368.         self.assertEqual(unified_timestamp('2017-03-30T17:52:41Q'), 1490896361)

  369.         self.assertEqual(unified_timestamp('Sep 11, 2013 | 5:49 AM'), 1378878540)

  370.         self.assertEqual(unified_timestamp('December 15, 2017 at 7:49 am'), 1513324140)

  371.         self.assertEqual(unified_timestamp('2018-03-14T08:32:43.1493874+00:00'), 1521016363)

  372. 

  373.     def test_determine_ext(self):

  374.         self.assertEqual(determine_ext('http://example.com/foo/bar.mp4/?download'), 'mp4')

  375.         self.assertEqual(determine_ext('http://example.com/foo/bar/?download', None), None)

  376.         self.assertEqual(determine_ext('http://example.com/foo/bar.nonext/?download', None), None)

  377.         self.assertEqual(determine_ext('http://example.com/foo/bar/mp4?download', None), None)

  378.         self.assertEqual(determine_ext('http://example.com/foo/bar.m3u8//?download'), 'm3u8')

  379.         self.assertEqual(determine_ext('foobar', None), None)

  380. 

  381.     def test_find_xpath_attr(self):

  382.         testxml = '''<root>

  383.             <node/>

  384.             <node x="a"/>

  385.             <node x="a" y="c" />

  386.             <node x="b" y="d" />

  387.             <node x="" />

  388.         </root>'''

  389.         doc = compat_etree_fromstring(testxml)

  390. 

  391.         self.assertEqual(find_xpath_attr(doc, './/fourohfour', 'n'), None)

  392.         self.assertEqual(find_xpath_attr(doc, './/fourohfour', 'n', 'v'), None)

  393.         self.assertEqual(find_xpath_attr(doc, './/node', 'n'), None)

  394.         self.assertEqual(find_xpath_attr(doc, './/node', 'n', 'v'), None)

  395.         self.assertEqual(find_xpath_attr(doc, './/node', 'x'), doc[1])

  396.         self.assertEqual(find_xpath_attr(doc, './/node', 'x', 'a'), doc[1])

  397.         self.assertEqual(find_xpath_attr(doc, './/node', 'x', 'b'), doc[3])

  398.         self.assertEqual(find_xpath_attr(doc, './/node', 'y'), doc[2])

  399.         self.assertEqual(find_xpath_attr(doc, './/node', 'y', 'c'), doc[2])

  400.         self.assertEqual(find_xpath_attr(doc, './/node', 'y', 'd'), doc[3])

  401.         self.assertEqual(find_xpath_attr(doc, './/node', 'x', ''), doc[4])

  402. 

  403.     def test_xpath_with_ns(self):

  404.         testxml = '''<root xmlns:media="http://example.com/">

  405.             <media:song>

  406.                 <media:author>The Author</media:author>

  407.                 <url>http://server.com/download.mp3</url>

  408.             </media:song>

  409.         </root>'''

  410.         doc = compat_etree_fromstring(testxml)

  411.         find = lambda p: doc.find(xpath_with_ns(p, {'media': 'http://example.com/'}))

  412.         self.assertTrue(find('media:song') is not None)

  413.         self.assertEqual(find('media:song/media:author').text, 'The Author')

  414.         self.assertEqual(find('media:song/url').text, 'http://server.com/download.mp3')

  415. 

  416.     def test_xpath_element(self):

  417.         doc = xml.etree.ElementTree.Element('root')

  418.         div = xml.etree.ElementTree.SubElement(doc, 'div')

  419.         p = xml.etree.ElementTree.SubElement(div, 'p')

  420.         p.text = 'Foo'

  421.         self.assertEqual(xpath_element(doc, 'div/p'), p)

  422.         self.assertEqual(xpath_element(doc, ['div/p']), p)

  423.         self.assertEqual(xpath_element(doc, ['div/bar', 'div/p']), p)

  424.         self.assertEqual(xpath_element(doc, 'div/bar', default='default'), 'default')

  425.         self.assertEqual(xpath_element(doc, ['div/bar'], default='default'), 'default')

  426.         self.assertTrue(xpath_element(doc, 'div/bar') is None)

  427.         self.assertTrue(xpath_element(doc, ['div/bar']) is None)

  428.         self.assertTrue(xpath_element(doc, ['div/bar'], 'div/baz') is None)

  429.         self.assertRaises(ExtractorError, xpath_element, doc, 'div/bar', fatal=True)

  430.         self.assertRaises(ExtractorError, xpath_element, doc, ['div/bar'], fatal=True)

  431.         self.assertRaises(ExtractorError, xpath_element, doc, ['div/bar', 'div/baz'], fatal=True)

  432. 

  433.     def test_xpath_text(self):

  434.         testxml = '''<root>

  435.             <div>

  436.                 <p>Foo</p>

  437.             </div>

  438.         </root>'''

  439.         doc = compat_etree_fromstring(testxml)

  440.         self.assertEqual(xpath_text(doc, 'div/p'), 'Foo')

  441.         self.assertEqual(xpath_text(doc, 'div/bar', default='default'), 'default')

  442.         self.assertTrue(xpath_text(doc, 'div/bar') is None)

  443.         self.assertRaises(ExtractorError, xpath_text, doc, 'div/bar', fatal=True)

  444. 

  445.     def test_xpath_attr(self):

  446.         testxml = '''<root>

  447.             <div>

  448.                 <p x="a">Foo</p>

  449.             </div>

  450.         </root>'''

  451.         doc = compat_etree_fromstring(testxml)

  452.         self.assertEqual(xpath_attr(doc, 'div/p', 'x'), 'a')

  453.         self.assertEqual(xpath_attr(doc, 'div/bar', 'x'), None)

  454.         self.assertEqual(xpath_attr(doc, 'div/p', 'y'), None)

  455.         self.assertEqual(xpath_attr(doc, 'div/bar', 'x', default='default'), 'default')

  456.         self.assertEqual(xpath_attr(doc, 'div/p', 'y', default='default'), 'default')

  457.         self.assertRaises(ExtractorError, xpath_attr, doc, 'div/bar', 'x', fatal=True)

  458.         self.assertRaises(ExtractorError, xpath_attr, doc, 'div/p', 'y', fatal=True)

  459. 

  460.     def test_smuggle_url(self):

  461.         data = {"ö": "ö", "abc": [3]}

  462.         url = 'https://foo.bar/baz?x=y#a'

  463.         smug_url = smuggle_url(url, data)

  464.         unsmug_url, unsmug_data = unsmuggle_url(smug_url)

  465.         self.assertEqual(url, unsmug_url)

  466.         self.assertEqual(data, unsmug_data)

  467. 

  468.         res_url, res_data = unsmuggle_url(url)

  469.         self.assertEqual(res_url, url)

  470.         self.assertEqual(res_data, None)

  471. 

  472.         smug_url = smuggle_url(url, {'a': 'b'})

  473.         smug_smug_url = smuggle_url(smug_url, {'c': 'd'})

  474.         res_url, res_data = unsmuggle_url(smug_smug_url)

  475.         self.assertEqual(res_url, url)

  476.         self.assertEqual(res_data, {'a': 'b', 'c': 'd'})

  477. 

  478.     def test_shell_quote(self):

  479.         args = ['ffmpeg', '-i', encodeFilename('ñ€ß\'.mp4')]

  480.         self.assertEqual(

  481.             shell_quote(args),

  482.             """ffmpeg -i 'ñ€ß'"'"'.mp4'""" if compat_os_name != 'nt' else '''ffmpeg -i "ñ€ß'.mp4"''')

  483. 

  484.     def test_float_or_none(self):

  485.         self.assertEqual(float_or_none('42.42'), 42.42)

  486.         self.assertEqual(float_or_none('42'), 42.0)

  487.         self.assertEqual(float_or_none(''), None)

  488.         self.assertEqual(float_or_none(None), None)

  489.         self.assertEqual(float_or_none([]), None)

  490.         self.assertEqual(float_or_none(set()), None)

  491. 

  492.     def test_int_or_none(self):

  493.         self.assertEqual(int_or_none('42'), 42)

  494.         self.assertEqual(int_or_none(''), None)

  495.         self.assertEqual(int_or_none(None), None)

  496.         self.assertEqual(int_or_none([]), None)

  497.         self.assertEqual(int_or_none(set()), None)

  498. 

  499.     def test_str_to_int(self):

  500.         self.assertEqual(str_to_int('123,456'), 123456)

  501.         self.assertEqual(str_to_int('123.456'), 123456)

  502.         self.assertEqual(str_to_int(523), 523)

  503.         # Python 3 has no long

  504.         if sys.version_info < (3, 0):

  505.             eval('self.assertEqual(str_to_int(123456L), 123456)')

  506.         self.assertEqual(str_to_int('noninteger'), None)

  507.         self.assertEqual(str_to_int([]), None)

  508. 

  509.     def test_url_basename(self):

  510.         self.assertEqual(url_basename('http://foo.de/'), '')

  511.         self.assertEqual(url_basename('http://foo.de/bar/baz'), 'baz')

  512.         self.assertEqual(url_basename('http://foo.de/bar/baz?x=y'), 'baz')

  513.         self.assertEqual(url_basename('http://foo.de/bar/baz#x=y'), 'baz')

  514.         self.assertEqual(url_basename('http://foo.de/bar/baz/'), 'baz')

  515.         self.assertEqual(

  516.             url_basename('http://media.w3.org/2010/05/sintel/trailer.mp4'),

  517.             'trailer.mp4')

  518. 

  519.     def test_base_url(self):

  520.         self.assertEqual(base_url('http://foo.de/'), 'http://foo.de/')

  521.         self.assertEqual(base_url('http://foo.de/bar'), 'http://foo.de/')

  522.         self.assertEqual(base_url('http://foo.de/bar/'), 'http://foo.de/bar/')

  523.         self.assertEqual(base_url('http://foo.de/bar/baz'), 'http://foo.de/bar/')

  524.         self.assertEqual(base_url('http://foo.de/bar/baz?x=z/x/c'), 'http://foo.de/bar/')

  525. 

  526.     def test_urljoin(self):

  527.         self.assertEqual(urljoin('http://foo.de/', '/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  528.         self.assertEqual(urljoin(b'http://foo.de/', '/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  529.         self.assertEqual(urljoin('http://foo.de/', b'/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  530.         self.assertEqual(urljoin(b'http://foo.de/', b'/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  531.         self.assertEqual(urljoin('//foo.de/', '/a/b/c.txt'), '//foo.de/a/b/c.txt')

  532.         self.assertEqual(urljoin('http://foo.de/', 'a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  533.         self.assertEqual(urljoin('http://foo.de', '/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  534.         self.assertEqual(urljoin('http://foo.de', 'a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  535.         self.assertEqual(urljoin('http://foo.de/', 'http://foo.de/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  536.         self.assertEqual(urljoin('http://foo.de/', '//foo.de/a/b/c.txt'), '//foo.de/a/b/c.txt')

  537.         self.assertEqual(urljoin(None, 'http://foo.de/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  538.         self.assertEqual(urljoin(None, '//foo.de/a/b/c.txt'), '//foo.de/a/b/c.txt')

  539.         self.assertEqual(urljoin('', 'http://foo.de/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  540.         self.assertEqual(urljoin(['foobar'], 'http://foo.de/a/b/c.txt'), 'http://foo.de/a/b/c.txt')

  541.         self.assertEqual(urljoin('http://foo.de/', None), None)

  542.         self.assertEqual(urljoin('http://foo.de/', ''), None)

  543.         self.assertEqual(urljoin('http://foo.de/', ['foobar']), None)

  544.         self.assertEqual(urljoin('http://foo.de/a/b/c.txt', '.././../d.txt'), 'http://foo.de/d.txt')

  545.         self.assertEqual(urljoin('http://foo.de/a/b/c.txt', 'rtmp://foo.de'), 'rtmp://foo.de')

  546.         self.assertEqual(urljoin(None, 'rtmp://foo.de'), 'rtmp://foo.de')

  547. 

  548.     def test_url_or_none(self):

  549.         self.assertEqual(url_or_none(None), None)

  550.         self.assertEqual(url_or_none(''), None)

  551.         self.assertEqual(url_or_none('foo'), None)

  552.         self.assertEqual(url_or_none('http://foo.de'), 'http://foo.de')

  553.         self.assertEqual(url_or_none('https://foo.de'), 'https://foo.de')

  554.         self.assertEqual(url_or_none('http$://foo.de'), None)

  555.         self.assertEqual(url_or_none('http://foo.de'), 'http://foo.de')

  556.         self.assertEqual(url_or_none('//foo.de'), '//foo.de')

  557. 

  558.     def test_parse_age_limit(self):

  559.         self.assertEqual(parse_age_limit(None), None)

  560.         self.assertEqual(parse_age_limit(False), None)

  561.         self.assertEqual(parse_age_limit('invalid'), None)

  562.         self.assertEqual(parse_age_limit(0), 0)

  563.         self.assertEqual(parse_age_limit(18), 18)

  564.         self.assertEqual(parse_age_limit(21), 21)

  565.         self.assertEqual(parse_age_limit(22), None)

  566.         self.assertEqual(parse_age_limit('18'), 18)

  567.         self.assertEqual(parse_age_limit('18+'), 18)

  568.         self.assertEqual(parse_age_limit('PG-13'), 13)

  569.         self.assertEqual(parse_age_limit('TV-14'), 14)

  570.         self.assertEqual(parse_age_limit('TV-MA'), 17)

  571.         self.assertEqual(parse_age_limit('TV14'), 14)

  572.         self.assertEqual(parse_age_limit('TV_G'), 0)

  573. 

  574.     def test_parse_duration(self):

  575.         self.assertEqual(parse_duration(None), None)

  576.         self.assertEqual(parse_duration(False), None)

  577.         self.assertEqual(parse_duration('invalid'), None)

  578.         self.assertEqual(parse_duration('1'), 1)

  579.         self.assertEqual(parse_duration('1337:12'), 80232)

  580.         self.assertEqual(parse_duration('9:12:43'), 33163)

  581.         self.assertEqual(parse_duration('12:00'), 720)

  582.         self.assertEqual(parse_duration('00:01:01'), 61)

  583.         self.assertEqual(parse_duration('x:y'), None)

  584.         self.assertEqual(parse_duration('3h11m53s'), 11513)

  585.         self.assertEqual(parse_duration('3h 11m 53s'), 11513)

  586.         self.assertEqual(parse_duration('3 hours 11 minutes 53 seconds'), 11513)

  587.         self.assertEqual(parse_duration('3 hours 11 mins 53 secs'), 11513)

  588.         self.assertEqual(parse_duration('62m45s'), 3765)

  589.         self.assertEqual(parse_duration('6m59s'), 419)

  590.         self.assertEqual(parse_duration('49s'), 49)

  591.         self.assertEqual(parse_duration('0h0m0s'), 0)

  592.         self.assertEqual(parse_duration('0m0s'), 0)

  593.         self.assertEqual(parse_duration('0s'), 0)

  594.         self.assertEqual(parse_duration('01:02:03.05'), 3723.05)

  595.         self.assertEqual(parse_duration('T30M38S'), 1838)

  596.         self.assertEqual(parse_duration('5 s'), 5)

  597.         self.assertEqual(parse_duration('3 min'), 180)

  598.         self.assertEqual(parse_duration('2.5 hours'), 9000)

  599.         self.assertEqual(parse_duration('02:03:04'), 7384)

  600.         self.assertEqual(parse_duration('01:02:03:04'), 93784)

  601.         self.assertEqual(parse_duration('1 hour 3 minutes'), 3780)

  602.         self.assertEqual(parse_duration('87 Min.'), 5220)

  603.         self.assertEqual(parse_duration('PT1H0.040S'), 3600.04)

  604.         self.assertEqual(parse_duration('PT00H03M30SZ'), 210)

  605.         self.assertEqual(parse_duration('P0Y0M0DT0H4M20.880S'), 260.88)

  606. 

  607.     def test_fix_xml_ampersands(self):

  608.         self.assertEqual(

  609.             fix_xml_ampersands('"&x=y&z=a'), '"&amp;x=y&amp;z=a')

  610.         self.assertEqual(

  611.             fix_xml_ampersands('"&amp;x=y&wrong;&z=a'),

  612.             '"&amp;x=y&amp;wrong;&amp;z=a')

  613.         self.assertEqual(

  614.             fix_xml_ampersands('&amp;&apos;&gt;&lt;&quot;'),

  615.             '&amp;&apos;&gt;&lt;&quot;')

  616.         self.assertEqual(

  617.             fix_xml_ampersands('&#1234;&#x1abC;'), '&#1234;&#x1abC;')

  618.         self.assertEqual(fix_xml_ampersands('&#&#'), '&amp;#&amp;#')

  619. 

  620.     def test_paged_list(self):

  621.         def testPL(size, pagesize, sliceargs, expected):

  622.             def get_page(pagenum):

  623.                 firstid = pagenum * pagesize

  624.                 upto = min(size, pagenum * pagesize + pagesize)

  625.                 for i in range(firstid, upto):

  626.                     yield i

  627. 

  628.             pl = OnDemandPagedList(get_page, pagesize)

  629.             got = pl.getslice(*sliceargs)

  630.             self.assertEqual(got, expected)

  631. 

  632.             iapl = InAdvancePagedList(get_page, size // pagesize + 1, pagesize)

  633.             got = iapl.getslice(*sliceargs)

  634.             self.assertEqual(got, expected)

  635. 

  636.         testPL(5, 2, (), [0, 1, 2, 3, 4])

  637.         testPL(5, 2, (1,), [1, 2, 3, 4])

  638.         testPL(5, 2, (2,), [2, 3, 4])

  639.         testPL(5, 2, (4,), [4])

  640.         testPL(5, 2, (0, 3), [0, 1, 2])

  641.         testPL(5, 2, (1, 4), [1, 2, 3])

  642.         testPL(5, 2, (2, 99), [2, 3, 4])

  643.         testPL(5, 2, (20, 99), [])

  644. 

  645.     def test_read_batch_urls(self):

  646.         f = io.StringIO('''\xef\xbb\xbf foo

  647.             bar\r

  648.             baz

  649.             # More after this line\r

  650.             ; or after this

  651.             bam''')

  652.         self.assertEqual(read_batch_urls(f), ['foo', 'bar', 'baz', 'bam'])

  653. 

  654.     def test_urlencode_postdata(self):

  655.         data = urlencode_postdata({'username': 'foo@bar.com', 'password': '1234'})

  656.         self.assertTrue(isinstance(data, bytes))

  657. 

  658.     def test_update_url_query(self):

  659.         def query_dict(url):

  660.             return compat_parse_qs(compat_urlparse.urlparse(url).query)

  661.         self.assertEqual(query_dict(update_url_query(

  662.             'http://example.com/path', {'quality': ['HD'], 'format': ['mp4']})),

  663.             query_dict('http://example.com/path?quality=HD&format=mp4'))

  664.         self.assertEqual(query_dict(update_url_query(

  665.             'http://example.com/path', {'system': ['LINUX', 'WINDOWS']})),

  666.             query_dict('http://example.com/path?system=LINUX&system=WINDOWS'))

  667.         self.assertEqual(query_dict(update_url_query(

  668.             'http://example.com/path', {'fields': 'id,formats,subtitles'})),

  669.             query_dict('http://example.com/path?fields=id,formats,subtitles'))

  670.         self.assertEqual(query_dict(update_url_query(

  671.             'http://example.com/path', {'fields': ('id,formats,subtitles', 'thumbnails')})),

  672.             query_dict('http://example.com/path?fields=id,formats,subtitles&fields=thumbnails'))

  673.         self.assertEqual(query_dict(update_url_query(

  674.             'http://example.com/path?manifest=f4m', {'manifest': []})),

  675.             query_dict('http://example.com/path'))

  676.         self.assertEqual(query_dict(update_url_query(

  677.             'http://example.com/path?system=LINUX&system=WINDOWS', {'system': 'LINUX'})),

  678.             query_dict('http://example.com/path?system=LINUX'))

  679.         self.assertEqual(query_dict(update_url_query(

  680.             'http://example.com/path', {'fields': b'id,formats,subtitles'})),

  681.             query_dict('http://example.com/path?fields=id,formats,subtitles'))

  682.         self.assertEqual(query_dict(update_url_query(

  683.             'http://example.com/path', {'width': 1080, 'height': 720})),

  684.             query_dict('http://example.com/path?width=1080&height=720'))

  685.         self.assertEqual(query_dict(update_url_query(

  686.             'http://example.com/path', {'bitrate': 5020.43})),

  687.             query_dict('http://example.com/path?bitrate=5020.43'))

  688.         self.assertEqual(query_dict(update_url_query(

  689.             'http://example.com/path', {'test': '第二行тест'})),

  690.             query_dict('http://example.com/path?test=%E7%AC%AC%E4%BA%8C%E8%A1%8C%D1%82%D0%B5%D1%81%D1%82'))

  691. 

  692.     def test_multipart_encode(self):

  693.         self.assertEqual(

  694.             multipart_encode({b'field': b'value'}, boundary='AAAAAA')[0],

  695.             b'--AAAAAA\r\nContent-Disposition: form-data; name="field"\r\n\r\nvalue\r\n--AAAAAA--\r\n')

  696.         self.assertEqual(

  697.             multipart_encode({'欄位'.encode('utf-8'): '值'.encode('utf-8')}, boundary='AAAAAA')[0],

  698.             b'--AAAAAA\r\nContent-Disposition: form-data; name="\xe6\xac\x84\xe4\xbd\x8d"\r\n\r\n\xe5\x80\xbc\r\n--AAAAAA--\r\n')

  699.         self.assertRaises(

  700.             ValueError, multipart_encode, {b'field': b'value'}, boundary='value')

  701. 

  702.     def test_dict_get(self):

  703.         FALSE_VALUES = {

  704.             'none': None,

  705.             'false': False,

  706.             'zero': 0,

  707.             'empty_string': '',

  708.             'empty_list': [],

  709.         }

  710.         d = FALSE_VALUES.copy()

  711.         d['a'] = 42

  712.         self.assertEqual(dict_get(d, 'a'), 42)

  713.         self.assertEqual(dict_get(d, 'b'), None)

  714.         self.assertEqual(dict_get(d, 'b', 42), 42)

  715.         self.assertEqual(dict_get(d, ('a', )), 42)

  716.         self.assertEqual(dict_get(d, ('b', 'a', )), 42)

  717.         self.assertEqual(dict_get(d, ('b', 'c', 'a', 'd', )), 42)

  718.         self.assertEqual(dict_get(d, ('b', 'c', )), None)

  719.         self.assertEqual(dict_get(d, ('b', 'c', ), 42), 42)

  720.         for key, false_value in FALSE_VALUES.items():

  721.             self.assertEqual(dict_get(d, ('b', 'c', key, )), None)

  722.             self.assertEqual(dict_get(d, ('b', 'c', key, ), skip_false_values=False), false_value)

  723. 

  724.     def test_merge_dicts(self):

  725.         self.assertEqual(merge_dicts({'a': 1}, {'b': 2}), {'a': 1, 'b': 2})

  726.         self.assertEqual(merge_dicts({'a': 1}, {'a': 2}), {'a': 1})

  727.         self.assertEqual(merge_dicts({'a': 1}, {'a': None}), {'a': 1})

  728.         self.assertEqual(merge_dicts({'a': 1}, {'a': ''}), {'a': 1})

  729.         self.assertEqual(merge_dicts({'a': 1}, {}), {'a': 1})

  730.         self.assertEqual(merge_dicts({'a': None}, {'a': 1}), {'a': 1})

  731.         self.assertEqual(merge_dicts({'a': ''}, {'a': 1}), {'a': ''})

  732.         self.assertEqual(merge_dicts({'a': ''}, {'a': 'abc'}), {'a': 'abc'})

  733.         self.assertEqual(merge_dicts({'a': None}, {'a': ''}, {'a': 'abc'}), {'a': 'abc'})

  734. 

  735.     def test_encode_compat_str(self):

  736.         self.assertEqual(encode_compat_str(b'\xd1\x82\xd0\xb5\xd1\x81\xd1\x82', 'utf-8'), 'тест')

  737.         self.assertEqual(encode_compat_str('тест', 'utf-8'), 'тест')

  738. 

  739.     def test_parse_iso8601(self):

  740.         self.assertEqual(parse_iso8601('2014-03-23T23:04:26+0100'), 1395612266)

  741.         self.assertEqual(parse_iso8601('2014-03-23T22:04:26+0000'), 1395612266)

  742.         self.assertEqual(parse_iso8601('2014-03-23T22:04:26Z'), 1395612266)

  743.         self.assertEqual(parse_iso8601('2014-03-23T22:04:26.1234Z'), 1395612266)

  744.         self.assertEqual(parse_iso8601('2015-09-29T08:27:31.727'), 1443515251)

  745.         self.assertEqual(parse_iso8601('2015-09-29T08-27-31.727'), None)

  746. 

  747.     def test_strip_jsonp(self):

  748.         stripped = strip_jsonp('cb ([ {"id":"532cb",\n\n\n"x":\n3}\n]\n);')

  749.         d = json.loads(stripped)

  750.         self.assertEqual(d, [{"id": "532cb", "x": 3}])

  751. 

  752.         stripped = strip_jsonp('parseMetadata({"STATUS":"OK"})\n\n\n//epc')

  753.         d = json.loads(stripped)

  754.         self.assertEqual(d, {'STATUS': 'OK'})

  755. 

  756.         stripped = strip_jsonp('ps.embedHandler({"status": "success"});')

  757.         d = json.loads(stripped)

  758.         self.assertEqual(d, {'status': 'success'})

  759. 

  760.         stripped = strip_jsonp('window.cb && window.cb({"status": "success"});')

  761.         d = json.loads(stripped)

  762.         self.assertEqual(d, {'status': 'success'})

  763. 

  764.         stripped = strip_jsonp('window.cb && cb({"status": "success"});')

  765.         d = json.loads(stripped)

  766.         self.assertEqual(d, {'status': 'success'})

  767. 

  768.         stripped = strip_jsonp('({"status": "success"});')

  769.         d = json.loads(stripped)

  770.         self.assertEqual(d, {'status': 'success'})

  771. 

  772.     def test_strip_or_none(self):

  773.         self.assertEqual(strip_or_none(' abc'), 'abc')

  774.         self.assertEqual(strip_or_none('abc '), 'abc')

  775.         self.assertEqual(strip_or_none(' abc '), 'abc')

  776.         self.assertEqual(strip_or_none('\tabc\t'), 'abc')

  777.         self.assertEqual(strip_or_none('\n\tabc\n\t'), 'abc')

  778.         self.assertEqual(strip_or_none('abc'), 'abc')

  779.         self.assertEqual(strip_or_none(''), '')

  780.         self.assertEqual(strip_or_none(None), None)

  781.         self.assertEqual(strip_or_none(42), None)

  782.         self.assertEqual(strip_or_none([]), None)

  783. 

  784.     def test_uppercase_escape(self):

  785.         self.assertEqual(uppercase_escape('aä'), 'aä')

  786.         self.assertEqual(uppercase_escape('\\U0001d550'), '𝕐')

  787. 

  788.     def test_lowercase_escape(self):

  789.         self.assertEqual(lowercase_escape('aä'), 'aä')

  790.         self.assertEqual(lowercase_escape('\\u0026'), '&')

  791. 

  792.     def test_limit_length(self):

  793.         self.assertEqual(limit_length(None, 12), None)

  794.         self.assertEqual(limit_length('foo', 12), 'foo')

  795.         self.assertTrue(

  796.             limit_length('foo bar baz asd', 12).startswith('foo bar'))

  797.         self.assertTrue('...' in limit_length('foo bar baz asd', 12))

  798. 

  799.     def test_mimetype2ext(self):

  800.         self.assertEqual(mimetype2ext(None), None)

  801.         self.assertEqual(mimetype2ext('video/x-flv'), 'flv')

  802.         self.assertEqual(mimetype2ext('application/x-mpegURL'), 'm3u8')

  803.         self.assertEqual(mimetype2ext('text/vtt'), 'vtt')

  804.         self.assertEqual(mimetype2ext('text/vtt;charset=utf-8'), 'vtt')

  805.         self.assertEqual(mimetype2ext('text/html; charset=utf-8'), 'html')

  806.         self.assertEqual(mimetype2ext('audio/x-wav'), 'wav')

  807.         self.assertEqual(mimetype2ext('audio/x-wav;codec=pcm'), 'wav')

  808. 

  809.     def test_month_by_name(self):

  810.         self.assertEqual(month_by_name(None), None)

  811.         self.assertEqual(month_by_name('December', 'en'), 12)

  812.         self.assertEqual(month_by_name('décembre', 'fr'), 12)

  813.         self.assertEqual(month_by_name('December'), 12)

  814.         self.assertEqual(month_by_name('décembre'), None)

  815.         self.assertEqual(month_by_name('Unknown', 'unknown'), None)

  816. 

  817.     def test_parse_codecs(self):

  818.         self.assertEqual(parse_codecs(''), {})

  819.         self.assertEqual(parse_codecs('avc1.77.30, mp4a.40.2'), {

  820.             'vcodec': 'avc1.77.30',

  821.             'acodec': 'mp4a.40.2',

  822.         })

  823.         self.assertEqual(parse_codecs('mp4a.40.2'), {

  824.             'vcodec': 'none',

  825.             'acodec': 'mp4a.40.2',

  826.         })

  827.         self.assertEqual(parse_codecs('mp4a.40.5,avc1.42001e'), {

  828.             'vcodec': 'avc1.42001e',

  829.             'acodec': 'mp4a.40.5',

  830.         })

  831.         self.assertEqual(parse_codecs('avc3.640028'), {

  832.             'vcodec': 'avc3.640028',

  833.             'acodec': 'none',

  834.         })

  835.         self.assertEqual(parse_codecs(', h264,,newcodec,aac'), {

  836.             'vcodec': 'h264',

  837.             'acodec': 'aac',

  838.         })

  839.         self.assertEqual(parse_codecs('av01.0.05M.08'), {

  840.             'vcodec': 'av01.0.05M.08',

  841.             'acodec': 'none',

  842.         })

  843.         self.assertEqual(parse_codecs('theora, vorbis'), {

  844.             'vcodec': 'theora',

  845.             'acodec': 'vorbis',

  846.         })

  847.         self.assertEqual(parse_codecs('unknownvcodec, unknownacodec'), {

  848.             'vcodec': 'unknownvcodec',

  849.             'acodec': 'unknownacodec',

  850.         })

  851.         self.assertEqual(parse_codecs('unknown'), {})

  852. 

  853.     def test_escape_rfc3986(self):

  854.         reserved = "!*'();:@&=+$,/?#[]"

  855.         unreserved = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~'

  856.         self.assertEqual(escape_rfc3986(reserved), reserved)

  857.         self.assertEqual(escape_rfc3986(unreserved), unreserved)

  858.         self.assertEqual(escape_rfc3986('тест'), '%D1%82%D0%B5%D1%81%D1%82')

  859.         self.assertEqual(escape_rfc3986('%D1%82%D0%B5%D1%81%D1%82'), '%D1%82%D0%B5%D1%81%D1%82')

  860.         self.assertEqual(escape_rfc3986('foo bar'), 'foo%20bar')

  861.         self.assertEqual(escape_rfc3986('foo%20bar'), 'foo%20bar')

  862. 

  863.     def test_escape_url(self):

  864.         self.assertEqual(

  865.             escape_url('http://wowza.imust.org/srv/vod/telemb/new/UPLOAD/UPLOAD/20224_IncendieHavré_FD.mp4'),

  866.             'http://wowza.imust.org/srv/vod/telemb/new/UPLOAD/UPLOAD/20224_IncendieHavre%CC%81_FD.mp4'

  867.         )

  868.         self.assertEqual(

  869.             escape_url('http://www.ardmediathek.de/tv/Sturm-der-Liebe/Folge-2036-Zu-Mann-und-Frau-erklärt/Das-Erste/Video?documentId=22673108&bcastId=5290'),

  870.             'http://www.ardmediathek.de/tv/Sturm-der-Liebe/Folge-2036-Zu-Mann-und-Frau-erkl%C3%A4rt/Das-Erste/Video?documentId=22673108&bcastId=5290'

  871.         )

  872.         self.assertEqual(

  873.             escape_url('http://тест.рф/фрагмент'),

  874.             'http://xn--e1aybc.xn--p1ai/%D1%84%D1%80%D0%B0%D0%B3%D0%BC%D0%B5%D0%BD%D1%82'

  875.         )

  876.         self.assertEqual(

  877.             escape_url('http://тест.рф/абв?абв=абв#абв'),

  878.             'http://xn--e1aybc.xn--p1ai/%D0%B0%D0%B1%D0%B2?%D0%B0%D0%B1%D0%B2=%D0%B0%D0%B1%D0%B2#%D0%B0%D0%B1%D0%B2'

  879.         )

  880.         self.assertEqual(escape_url('http://vimeo.com/56015672#at=0'), 'http://vimeo.com/56015672#at=0')

  881. 

  882.     def test_js_to_json_realworld(self):

  883.         inp = '''{

  884.             'clip':{'provider':'pseudo'}

  885.         }'''

  886.         self.assertEqual(js_to_json(inp), '''{

  887.             "clip":{"provider":"pseudo"}

  888.         }''')

  889.         json.loads(js_to_json(inp))

  890. 

  891.         inp = '''{

  892.             'playlist':[{'controls':{'all':null}}]

  893.         }'''

  894.         self.assertEqual(js_to_json(inp), '''{

  895.             "playlist":[{"controls":{"all":null}}]

  896.         }''')

  897. 

  898.         inp = '''"The CW\\'s \\'Crazy Ex-Girlfriend\\'"'''

  899.         self.assertEqual(js_to_json(inp), '''"The CW's 'Crazy Ex-Girlfriend'"''')

  900. 

  901.         inp = '"SAND Number: SAND 2013-7800P\\nPresenter: Tom Russo\\nHabanero Software Training - Xyce Software\\nXyce, Sandia\\u0027s"'

  902.         json_code = js_to_json(inp)

  903.         self.assertEqual(json.loads(json_code), json.loads(inp))

  904. 

  905.         inp = '''{

  906.             0:{src:'skipped', type: 'application/dash+xml'},

  907.             1:{src:'skipped', type: 'application/vnd.apple.mpegURL'},

  908.         }'''

  909.         self.assertEqual(js_to_json(inp), '''{

  910.             "0":{"src":"skipped", "type": "application/dash+xml"},

  911.             "1":{"src":"skipped", "type": "application/vnd.apple.mpegURL"}

  912.         }''')

  913. 

  914.         inp = '''{"foo":101}'''

  915.         self.assertEqual(js_to_json(inp), '''{"foo":101}''')

  916. 

  917.         inp = '''{"duration": "00:01:07"}'''

  918.         self.assertEqual(js_to_json(inp), '''{"duration": "00:01:07"}''')

  919. 

  920.         inp = '''{segments: [{"offset":-3.885780586188048e-16,"duration":39.75000000000001}]}'''

  921.         self.assertEqual(js_to_json(inp), '''{"segments": [{"offset":-3.885780586188048e-16,"duration":39.75000000000001}]}''')

  922. 

  923.     def test_js_to_json_edgecases(self):

  924.         on = js_to_json("{abc_def:'1\\'\\\\2\\\\\\'3\"4'}")

  925.         self.assertEqual(json.loads(on), {"abc_def": "1'\\2\\'3\"4"})

  926. 

  927.         on = js_to_json('{"abc": true}')

  928.         self.assertEqual(json.loads(on), {'abc': True})

  929. 

  930.         # Ignore JavaScript code as well

  931.         on = js_to_json('''{

  932.             "x": 1,

  933.             y: "a",

  934.             z: some.code

  935.         }''')

  936.         d = json.loads(on)

  937.         self.assertEqual(d['x'], 1)

  938.         self.assertEqual(d['y'], 'a')

  939. 

  940.         on = js_to_json('["abc", "def",]')

  941.         self.assertEqual(json.loads(on), ['abc', 'def'])

  942. 

  943.         on = js_to_json('[/*comment\n*/"abc"/*comment\n*/,/*comment\n*/"def",/*comment\n*/]')

  944.         self.assertEqual(json.loads(on), ['abc', 'def'])

  945. 

  946.         on = js_to_json('[//comment\n"abc" //comment\n,//comment\n"def",//comment\n]')

  947.         self.assertEqual(json.loads(on), ['abc', 'def'])

  948. 

  949.         on = js_to_json('{"abc": "def",}')

  950.         self.assertEqual(json.loads(on), {'abc': 'def'})

  951. 

  952.         on = js_to_json('{/*comment\n*/"abc"/*comment\n*/:/*comment\n*/"def"/*comment\n*/,/*comment\n*/}')

  953.         self.assertEqual(json.loads(on), {'abc': 'def'})

  954. 

  955.         on = js_to_json('{ 0: /* " \n */ ",]" , }')

  956.         self.assertEqual(json.loads(on), {'0': ',]'})

  957. 

  958.         on = js_to_json('{ /*comment\n*/0/*comment\n*/: /* " \n */ ",]" , }')

  959.         self.assertEqual(json.loads(on), {'0': ',]'})

  960. 

  961.         on = js_to_json('{ 0: // comment\n1 }')

  962.         self.assertEqual(json.loads(on), {'0': 1})

  963. 

  964.         on = js_to_json(r'["<p>x<\/p>"]')

  965.         self.assertEqual(json.loads(on), ['<p>x</p>'])

  966. 

  967.         on = js_to_json(r'["\xaa"]')

  968.         self.assertEqual(json.loads(on), ['\u00aa'])

  969. 

  970.         on = js_to_json("['a\\\nb']")

  971.         self.assertEqual(json.loads(on), ['ab'])

  972. 

  973.         on = js_to_json("/*comment\n*/[/*comment\n*/'a\\\nb'/*comment\n*/]/*comment\n*/")

  974.         self.assertEqual(json.loads(on), ['ab'])

  975. 

  976.         on = js_to_json('{0xff:0xff}')

  977.         self.assertEqual(json.loads(on), {'255': 255})

  978. 

  979.         on = js_to_json('{/*comment\n*/0xff/*comment\n*/:/*comment\n*/0xff/*comment\n*/}')

  980.         self.assertEqual(json.loads(on), {'255': 255})

  981. 

  982.         on = js_to_json('{077:077}')

  983.         self.assertEqual(json.loads(on), {'63': 63})

  984. 

  985.         on = js_to_json('{/*comment\n*/077/*comment\n*/:/*comment\n*/077/*comment\n*/}')

  986.         self.assertEqual(json.loads(on), {'63': 63})

  987. 

  988.         on = js_to_json('{42:42}')

  989.         self.assertEqual(json.loads(on), {'42': 42})

  990. 

  991.         on = js_to_json('{/*comment\n*/42/*comment\n*/:/*comment\n*/42/*comment\n*/}')

  992.         self.assertEqual(json.loads(on), {'42': 42})

  993. 

  994.         on = js_to_json('{42:4.2e1}')

  995.         self.assertEqual(json.loads(on), {'42': 42.0})

  996. 

  997.         on = js_to_json('{ "0x40": "0x40" }')

  998.         self.assertEqual(json.loads(on), {'0x40': '0x40'})

  999. 

  1000.         on = js_to_json('{ "040": "040" }')

  1001.         self.assertEqual(json.loads(on), {'040': '040'})

  1002. 

  1003.     def test_js_to_json_malformed(self):

  1004.         self.assertEqual(js_to_json('42a1'), '42"a1"')

  1005.         self.assertEqual(js_to_json('42a-1'), '42"a"-1')

  1006. 

  1007.     def test_extract_attributes(self):

  1008.         self.assertEqual(extract_attributes('<e x="y">'), {'x': 'y'})

  1009.         self.assertEqual(extract_attributes("<e x='y'>"), {'x': 'y'})

  1010.         self.assertEqual(extract_attributes('<e x=y>'), {'x': 'y'})

  1011.         self.assertEqual(extract_attributes('<e x="a \'b\' c">'), {'x': "a 'b' c"})

  1012.         self.assertEqual(extract_attributes('<e x=\'a "b" c\'>'), {'x': 'a "b" c'})

  1013.         self.assertEqual(extract_attributes('<e x="&#121;">'), {'x': 'y'})

  1014.         self.assertEqual(extract_attributes('<e x="&#x79;">'), {'x': 'y'})

  1015.         self.assertEqual(extract_attributes('<e x="&amp;">'), {'x': '&'})  # XML

  1016.         self.assertEqual(extract_attributes('<e x="&quot;">'), {'x': '"'})

  1017.         self.assertEqual(extract_attributes('<e x="&pound;">'), {'x': '£'})  # HTML 3.2

  1018.         self.assertEqual(extract_attributes('<e x="&lambda;">'), {'x': 'λ'})  # HTML 4.0

  1019.         self.assertEqual(extract_attributes('<e x="&foo">'), {'x': '&foo'})

  1020.         self.assertEqual(extract_attributes('<e x="\'">'), {'x': "'"})

  1021.         self.assertEqual(extract_attributes('<e x=\'"\'>'), {'x': '"'})

  1022.         self.assertEqual(extract_attributes('<e x >'), {'x': None})

  1023.         self.assertEqual(extract_attributes('<e x=y a>'), {'x': 'y', 'a': None})

  1024.         self.assertEqual(extract_attributes('<e x= y>'), {'x': 'y'})

  1025.         self.assertEqual(extract_attributes('<e x=1 y=2 x=3>'), {'y': '2', 'x': '3'})

  1026.         self.assertEqual(extract_attributes('<e \nx=\ny\n>'), {'x': 'y'})

  1027.         self.assertEqual(extract_attributes('<e \nx=\n"y"\n>'), {'x': 'y'})

  1028.         self.assertEqual(extract_attributes("<e \nx=\n'y'\n>"), {'x': 'y'})

  1029.         self.assertEqual(extract_attributes('<e \nx="\ny\n">'), {'x': '\ny\n'})

  1030.         self.assertEqual(extract_attributes('<e CAPS=x>'), {'caps': 'x'})  # Names lowercased

  1031.         self.assertEqual(extract_attributes('<e x=1 X=2>'), {'x': '2'})

  1032.         self.assertEqual(extract_attributes('<e X=1 x=2>'), {'x': '2'})

  1033.         self.assertEqual(extract_attributes('<e _:funny-name1=1>'), {'_:funny-name1': '1'})

  1034.         self.assertEqual(extract_attributes('<e x="Fáilte 世界 \U0001f600">'), {'x': 'Fáilte 世界 \U0001f600'})

  1035.         self.assertEqual(extract_attributes('<e x="décompose&#769;">'), {'x': 'décompose\u0301'})

  1036.         # "Narrow" Python builds don't support unicode code points outside BMP.

  1037.         try:

  1038.             compat_chr(0x10000)

  1039.             supports_outside_bmp = True

  1040.         except ValueError:

  1041.             supports_outside_bmp = False

  1042.         if supports_outside_bmp:

  1043.             self.assertEqual(extract_attributes('<e x="Smile &#128512;!">'), {'x': 'Smile \U0001f600!'})

  1044.         # Malformed HTML should not break attributes extraction on older Python

  1045.         self.assertEqual(extract_attributes('<mal"formed/>'), {})

  1046. 

  1047.     def test_clean_html(self):

  1048.         self.assertEqual(clean_html('a:\nb'), 'a: b')

  1049.         self.assertEqual(clean_html('a:\n   "b"'), 'a:    "b"')

  1050.         self.assertEqual(clean_html('a<br>\xa0b'), 'a\nb')

  1051. 

  1052.     def test_intlist_to_bytes(self):

  1053.         self.assertEqual(

  1054.             intlist_to_bytes([0, 1, 127, 128, 255]),

  1055.             b'\x00\x01\x7f\x80\xff')

  1056. 

  1057.     def test_args_to_str(self):

  1058.         self.assertEqual(

  1059.             args_to_str(['foo', 'ba/r', '-baz', '2 be', '']),

  1060.             'foo ba/r -baz \'2 be\' \'\'' if compat_os_name != 'nt' else 'foo ba/r -baz "2 be" ""'

  1061.         )

  1062. 

  1063.     def test_parse_filesize(self):

  1064.         self.assertEqual(parse_filesize(None), None)

  1065.         self.assertEqual(parse_filesize(''), None)

  1066.         self.assertEqual(parse_filesize('91 B'), 91)

  1067.         self.assertEqual(parse_filesize('foobar'), None)

  1068.         self.assertEqual(parse_filesize('2 MiB'), 2097152)

  1069.         self.assertEqual(parse_filesize('5 GB'), 5000000000)

  1070.         self.assertEqual(parse_filesize('1.2Tb'), 1200000000000)

  1071.         self.assertEqual(parse_filesize('1.2tb'), 1200000000000)

  1072.         self.assertEqual(parse_filesize('1,24 KB'), 1240)

  1073.         self.assertEqual(parse_filesize('1,24 kb'), 1240)

  1074.         self.assertEqual(parse_filesize('8.5 megabytes'), 8500000)

  1075. 

  1076.     def test_parse_count(self):

  1077.         self.assertEqual(parse_count(None), None)

  1078.         self.assertEqual(parse_count(''), None)

  1079.         self.assertEqual(parse_count('0'), 0)

  1080.         self.assertEqual(parse_count('1000'), 1000)

  1081.         self.assertEqual(parse_count('1.000'), 1000)

  1082.         self.assertEqual(parse_count('1.1k'), 1100)

  1083.         self.assertEqual(parse_count('1.1kk'), 1100000)

  1084.         self.assertEqual(parse_count('1.1kk '), 1100000)

  1085.         self.assertEqual(parse_count('1.1kk views'), 1100000)

  1086. 

  1087.     def test_parse_resolution(self):

  1088.         self.assertEqual(parse_resolution(None), {})

  1089.         self.assertEqual(parse_resolution(''), {})

  1090.         self.assertEqual(parse_resolution('1920x1080'), {'width': 1920, 'height': 1080})

  1091.         self.assertEqual(parse_resolution('1920×1080'), {'width': 1920, 'height': 1080})

  1092.         self.assertEqual(parse_resolution('1920 x 1080'), {'width': 1920, 'height': 1080})

  1093.         self.assertEqual(parse_resolution('720p'), {'height': 720})

  1094.         self.assertEqual(parse_resolution('4k'), {'height': 2160})

  1095.         self.assertEqual(parse_resolution('8K'), {'height': 4320})

  1096. 

  1097.     def test_parse_bitrate(self):

  1098.         self.assertEqual(parse_bitrate(None), None)

  1099.         self.assertEqual(parse_bitrate(''), None)

  1100.         self.assertEqual(parse_bitrate('300kbps'), 300)

  1101.         self.assertEqual(parse_bitrate('1500kbps'), 1500)

  1102.         self.assertEqual(parse_bitrate('300 kbps'), 300)

  1103. 

  1104.     def test_version_tuple(self):

  1105.         self.assertEqual(version_tuple('1'), (1,))

  1106.         self.assertEqual(version_tuple('10.23.344'), (10, 23, 344))

  1107.         self.assertEqual(version_tuple('10.1-6'), (10, 1, 6))  # avconv style

  1108. 

  1109.     def test_detect_exe_version(self):

  1110.         self.assertEqual(detect_exe_version('''ffmpeg version 1.2.1

  1111. built on May 27 2013 08:37:26 with gcc 4.7 (Debian 4.7.3-4)

  1112. configuration: --prefix=/usr --extra-'''), '1.2.1')

  1113.         self.assertEqual(detect_exe_version('''ffmpeg version N-63176-g1fb4685

  1114. built on May 15 2014 22:09:06 with gcc 4.8.2 (GCC)'''), 'N-63176-g1fb4685')

  1115.         self.assertEqual(detect_exe_version('''X server found. dri2 connection failed!

  1116. Trying to open render node...

  1117. Success at /dev/dri/renderD128.

  1118. ffmpeg version 2.4.4 Copyright (c) 2000-2014 the FFmpeg ...'''), '2.4.4')

  1119. 

  1120.     def test_age_restricted(self):

  1121.         self.assertFalse(age_restricted(None, 10))  # unrestricted content

  1122.         self.assertFalse(age_restricted(1, None))  # unrestricted policy

  1123.         self.assertFalse(age_restricted(8, 10))

  1124.         self.assertTrue(age_restricted(18, 14))

  1125.         self.assertFalse(age_restricted(18, 18))

  1126. 

  1127.     def test_is_html(self):

  1128.         self.assertFalse(is_html(b'\x49\x44\x43<html'))

  1129.         self.assertTrue(is_html(b'<!DOCTYPE foo>\xaaa'))

  1130.         self.assertTrue(is_html(  # UTF-8 with BOM

  1131.             b'\xef\xbb\xbf<!DOCTYPE foo>\xaaa'))

  1132.         self.assertTrue(is_html(  # UTF-16-LE

  1133.             b'\xff\xfe<\x00h\x00t\x00m\x00l\x00>\x00\xe4\x00'

  1134.         ))

  1135.         self.assertTrue(is_html(  # UTF-16-BE

  1136.             b'\xfe\xff\x00<\x00h\x00t\x00m\x00l\x00>\x00\xe4'

  1137.         ))

  1138.         self.assertTrue(is_html(  # UTF-32-BE

  1139.             b'\x00\x00\xFE\xFF\x00\x00\x00<\x00\x00\x00h\x00\x00\x00t\x00\x00\x00m\x00\x00\x00l\x00\x00\x00>\x00\x00\x00\xe4'))

  1140.         self.assertTrue(is_html(  # UTF-32-LE

  1141.             b'\xFF\xFE\x00\x00<\x00\x00\x00h\x00\x00\x00t\x00\x00\x00m\x00\x00\x00l\x00\x00\x00>\x00\x00\x00\xe4\x00\x00\x00'))

  1142. 

  1143.     def test_render_table(self):

  1144.         self.assertEqual(

  1145.             render_table(

  1146.                 ['a', 'bcd'],

  1147.                 [[123, 4], [9999, 51]]),

  1148.             'a    bcd\n'

  1149.             '123  4\n'

  1150.             '9999 51')

  1151. 

  1152.     def test_match_str(self):

  1153.         self.assertRaises(ValueError, match_str, 'xy>foobar', {})

  1154.         self.assertFalse(match_str('xy', {'x': 1200}))

  1155.         self.assertTrue(match_str('!xy', {'x': 1200}))

  1156.         self.assertTrue(match_str('x', {'x': 1200}))

  1157.         self.assertFalse(match_str('!x', {'x': 1200}))

  1158.         self.assertTrue(match_str('x', {'x': 0}))

  1159.         self.assertFalse(match_str('x>0', {'x': 0}))

  1160.         self.assertFalse(match_str('x>0', {}))

  1161.         self.assertTrue(match_str('x>?0', {}))

  1162.         self.assertTrue(match_str('x>1K', {'x': 1200}))

  1163.         self.assertFalse(match_str('x>2K', {'x': 1200}))

  1164.         self.assertTrue(match_str('x>=1200 & x < 1300', {'x': 1200}))

  1165.         self.assertFalse(match_str('x>=1100 & x < 1200', {'x': 1200}))

  1166.         self.assertFalse(match_str('y=a212', {'y': 'foobar42'}))

  1167.         self.assertTrue(match_str('y=foobar42', {'y': 'foobar42'}))

  1168.         self.assertFalse(match_str('y!=foobar42', {'y': 'foobar42'}))

  1169.         self.assertTrue(match_str('y!=foobar2', {'y': 'foobar42'}))

  1170.         self.assertFalse(match_str(

  1171.             'like_count > 100 & dislike_count <? 50 & description',

  1172.             {'like_count': 90, 'description': 'foo'}))

  1173.         self.assertTrue(match_str(

  1174.             'like_count > 100 & dislike_count <? 50 & description',

  1175.             {'like_count': 190, 'description': 'foo'}))

  1176.         self.assertFalse(match_str(

  1177.             'like_count > 100 & dislike_count <? 50 & description',

  1178.             {'like_count': 190, 'dislike_count': 60, 'description': 'foo'}))

  1179.         self.assertFalse(match_str(

  1180.             'like_count > 100 & dislike_count <? 50 & description',

  1181.             {'like_count': 190, 'dislike_count': 10}))

  1182.         self.assertTrue(match_str('is_live', {'is_live': True}))

  1183.         self.assertFalse(match_str('is_live', {'is_live': False}))

  1184.         self.assertFalse(match_str('is_live', {'is_live': None}))

  1185.         self.assertFalse(match_str('is_live', {}))

  1186.         self.assertFalse(match_str('!is_live', {'is_live': True}))

  1187.         self.assertTrue(match_str('!is_live', {'is_live': False}))

  1188.         self.assertTrue(match_str('!is_live', {'is_live': None}))

  1189.         self.assertTrue(match_str('!is_live', {}))

  1190.         self.assertTrue(match_str('title', {'title': 'abc'}))

  1191.         self.assertTrue(match_str('title', {'title': ''}))

  1192.         self.assertFalse(match_str('!title', {'title': 'abc'}))

  1193.         self.assertFalse(match_str('!title', {'title': ''}))

  1194. 

  1195.     def test_parse_dfxp_time_expr(self):

  1196.         self.assertEqual(parse_dfxp_time_expr(None), None)

  1197.         self.assertEqual(parse_dfxp_time_expr(''), None)

  1198.         self.assertEqual(parse_dfxp_time_expr('0.1'), 0.1)

  1199.         self.assertEqual(parse_dfxp_time_expr('0.1s'), 0.1)

  1200.         self.assertEqual(parse_dfxp_time_expr('00:00:01'), 1.0)

  1201.         self.assertEqual(parse_dfxp_time_expr('00:00:01.100'), 1.1)

  1202.         self.assertEqual(parse_dfxp_time_expr('00:00:01:100'), 1.1)

  1203. 

  1204.     def test_dfxp2srt(self):

  1205.         dfxp_data = '''<?xml version="1.0" encoding="UTF-8"?>

  1206.             <tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en" xmlns:tts="http://www.w3.org/ns/ttml#parameter">

  1207.             <body>

  1208.                 <div xml:lang="en">

  1209.                     <p begin="0" end="1">The following line contains Chinese characters and special symbols</p>

  1210.                     <p begin="1" end="2">第二行<br/>♪♪</p>

  1211.                     <p begin="2" dur="1"><span>Third<br/>Line</span></p>

  1212.                     <p begin="3" end="-1">Lines with invalid timestamps are ignored</p>

  1213.                     <p begin="-1" end="-1">Ignore, two</p>

  1214.                     <p begin="3" dur="-1">Ignored, three</p>

  1215.                 </div>

  1216.             </body>

  1217.             </tt>'''.encode('utf-8')

  1218.         srt_data = '''1

  1219. 00:00:00,000 --> 00:00:01,000

  1220. The following line contains Chinese characters and special symbols

  1221. 

  1222. 2

  1223. 00:00:01,000 --> 00:00:02,000

  1224. 第二行

  1225. ♪♪

  1226. 

  1227. 3

  1228. 00:00:02,000 --> 00:00:03,000

  1229. Third

  1230. Line

  1231. 

  1232. '''

  1233.         self.assertEqual(dfxp2srt(dfxp_data), srt_data)

  1234. 

  1235.         dfxp_data_no_default_namespace = '''<?xml version="1.0" encoding="UTF-8"?>

  1236.             <tt xml:lang="en" xmlns:tts="http://www.w3.org/ns/ttml#parameter">

  1237.             <body>

  1238.                 <div xml:lang="en">

  1239.                     <p begin="0" end="1">The first line</p>

  1240.                 </div>

  1241.             </body>

  1242.             </tt>'''.encode('utf-8')

  1243.         srt_data = '''1

  1244. 00:00:00,000 --> 00:00:01,000

  1245. The first line

  1246. 

  1247. '''

  1248.         self.assertEqual(dfxp2srt(dfxp_data_no_default_namespace), srt_data)

  1249. 

  1250.         dfxp_data_with_style = '''<?xml version="1.0" encoding="utf-8"?>

  1251. <tt xmlns="http://www.w3.org/2006/10/ttaf1" xmlns:ttp="http://www.w3.org/2006/10/ttaf1#parameter" ttp:timeBase="media" xmlns:tts="http://www.w3.org/2006/10/ttaf1#style" xml:lang="en" xmlns:ttm="http://www.w3.org/2006/10/ttaf1#metadata">

  1252.   <head>

  1253.     <styling>

  1254.       <style id="s2" style="s0" tts:color="cyan" tts:fontWeight="bold" />

  1255.       <style id="s1" style="s0" tts:color="yellow" tts:fontStyle="italic" />

  1256.       <style id="s3" style="s0" tts:color="lime" tts:textDecoration="underline" />

  1257.       <style id="s0" tts:backgroundColor="black" tts:fontStyle="normal" tts:fontSize="16" tts:fontFamily="sansSerif" tts:color="white" />

  1258.     </styling>

  1259.   </head>

  1260.   <body tts:textAlign="center" style="s0">

  1261.     <div>

  1262.       <p begin="00:00:02.08" id="p0" end="00:00:05.84">default style<span tts:color="red">custom style</span></p>

  1263.       <p style="s2" begin="00:00:02.08" id="p0" end="00:00:05.84"><span tts:color="lime">part 1<br /></span><span tts:color="cyan">part 2</span></p>

  1264.       <p style="s3" begin="00:00:05.84" id="p1" end="00:00:09.56">line 3<br />part 3</p>

  1265.       <p style="s1" tts:textDecoration="underline" begin="00:00:09.56" id="p2" end="00:00:12.36"><span style="s2" tts:color="lime">inner<br /> </span>style</p>

  1266.     </div>

  1267.   </body>

  1268. </tt>'''.encode('utf-8')

  1269.         srt_data = '''1

  1270. 00:00:02,080 --> 00:00:05,839

  1271. <font color="white" face="sansSerif" size="16">default style<font color="red">custom style</font></font>

  1272. 

  1273. 2

  1274. 00:00:02,080 --> 00:00:05,839

  1275. <b><font color="cyan" face="sansSerif" size="16"><font color="lime">part 1

  1276. </font>part 2</font></b>

  1277. 

  1278. 3

  1279. 00:00:05,839 --> 00:00:09,560

  1280. <u><font color="lime">line 3

  1281. part 3</font></u>

  1282. 

  1283. 4

  1284. 00:00:09,560 --> 00:00:12,359

  1285. <i><u><font color="yellow"><font color="lime">inner

  1286.  </font>style</font></u></i>

  1287. 

  1288. '''

  1289.         self.assertEqual(dfxp2srt(dfxp_data_with_style), srt_data)

  1290. 

  1291.         dfxp_data_non_utf8 = '''<?xml version="1.0" encoding="UTF-16"?>

  1292.             <tt xmlns="http://www.w3.org/ns/ttml" xml:lang="en" xmlns:tts="http://www.w3.org/ns/ttml#parameter">

  1293.             <body>

  1294.                 <div xml:lang="en">

  1295.                     <p begin="0" end="1">Line 1</p>

  1296.                     <p begin="1" end="2">第二行</p>

  1297.                 </div>

  1298.             </body>

  1299.             </tt>'''.encode('utf-16')

  1300.         srt_data = '''1

  1301. 00:00:00,000 --> 00:00:01,000

  1302. Line 1

  1303. 

  1304. 2

  1305. 00:00:01,000 --> 00:00:02,000

  1306. 第二行

  1307. 

  1308. '''

  1309.         self.assertEqual(dfxp2srt(dfxp_data_non_utf8), srt_data)

  1310. 

  1311.     def test_cli_option(self):

  1312.         self.assertEqual(cli_option({'proxy': '127.0.0.1:3128'}, '--proxy', 'proxy'), ['--proxy', '127.0.0.1:3128'])

  1313.         self.assertEqual(cli_option({'proxy': None}, '--proxy', 'proxy'), [])

  1314.         self.assertEqual(cli_option({}, '--proxy', 'proxy'), [])

  1315.         self.assertEqual(cli_option({'retries': 10}, '--retries', 'retries'), ['--retries', '10'])

  1316. 

  1317.     def test_cli_valueless_option(self):

  1318.         self.assertEqual(cli_valueless_option(

  1319.             {'downloader': 'external'}, '--external-downloader', 'downloader', 'external'), ['--external-downloader'])

  1320.         self.assertEqual(cli_valueless_option(

  1321.             {'downloader': 'internal'}, '--external-downloader', 'downloader', 'external'), [])

  1322.         self.assertEqual(cli_valueless_option(

  1323.             {'nocheckcertificate': True}, '--no-check-certificate', 'nocheckcertificate'), ['--no-check-certificate'])

  1324.         self.assertEqual(cli_valueless_option(

  1325.             {'nocheckcertificate': False}, '--no-check-certificate', 'nocheckcertificate'), [])

  1326.         self.assertEqual(cli_valueless_option(

  1327.             {'checkcertificate': True}, '--no-check-certificate', 'checkcertificate', False), [])

  1328.         self.assertEqual(cli_valueless_option(

  1329.             {'checkcertificate': False}, '--no-check-certificate', 'checkcertificate', False), ['--no-check-certificate'])

  1330. 

  1331.     def test_cli_bool_option(self):

  1332.         self.assertEqual(

  1333.             cli_bool_option(

  1334.                 {'nocheckcertificate': True}, '--no-check-certificate', 'nocheckcertificate'),

  1335.             ['--no-check-certificate', 'true'])

  1336.         self.assertEqual(

  1337.             cli_bool_option(

  1338.                 {'nocheckcertificate': True}, '--no-check-certificate', 'nocheckcertificate', separator='='),

  1339.             ['--no-check-certificate=true'])

  1340.         self.assertEqual(

  1341.             cli_bool_option(

  1342.                 {'nocheckcertificate': True}, '--check-certificate', 'nocheckcertificate', 'false', 'true'),

  1343.             ['--check-certificate', 'false'])

  1344.         self.assertEqual(

  1345.             cli_bool_option(

  1346.                 {'nocheckcertificate': True}, '--check-certificate', 'nocheckcertificate', 'false', 'true', '='),

  1347.             ['--check-certificate=false'])

  1348.         self.assertEqual(

  1349.             cli_bool_option(

  1350.                 {'nocheckcertificate': False}, '--check-certificate', 'nocheckcertificate', 'false', 'true'),

  1351.             ['--check-certificate', 'true'])

  1352.         self.assertEqual(

  1353.             cli_bool_option(

  1354.                 {'nocheckcertificate': False}, '--check-certificate', 'nocheckcertificate', 'false', 'true', '='),

  1355.             ['--check-certificate=true'])

  1356.         self.assertEqual(

  1357.             cli_bool_option(

  1358.                 {}, '--check-certificate', 'nocheckcertificate', 'false', 'true', '='),

  1359.             [])

  1360. 

  1361.     def test_ohdave_rsa_encrypt(self):

  1362.         N = 0xab86b6371b5318aaa1d3c9e612a9f1264f372323c8c0f19875b5fc3b3fd3afcc1e5bec527aa94bfa85bffc157e4245aebda05389a5357b75115ac94f074aefcd

  1363.         e = 65537

  1364. 

  1365.         self.assertEqual(

  1366.             ohdave_rsa_encrypt(b'aa111222', e, N),

  1367.             '726664bd9a23fd0c70f9f1b84aab5e3905ce1e45a584e9cbcf9bcc7510338fc1986d6c599ff990d923aa43c51c0d9013cd572e13bc58f4ae48f2ed8c0b0ba881')

  1368. 

  1369.     def test_pkcs1pad(self):

  1370.         data = [1, 2, 3]

  1371.         padded_data = pkcs1pad(data, 32)

  1372.         self.assertEqual(padded_data[:2], [0, 2])

  1373.         self.assertEqual(padded_data[28:], [0, 1, 2, 3])

  1374. 

  1375.         self.assertRaises(ValueError, pkcs1pad, data, 8)

  1376. 

  1377.     def test_encode_base_n(self):

  1378.         self.assertEqual(encode_base_n(0, 30), '0')

  1379.         self.assertEqual(encode_base_n(80, 30), '2k')

  1380. 

  1381.         custom_table = '9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA'

  1382.         self.assertEqual(encode_base_n(0, 30, custom_table), '9')

  1383.         self.assertEqual(encode_base_n(80, 30, custom_table), '7P')

  1384. 

  1385.         self.assertRaises(ValueError, encode_base_n, 0, 70)

  1386.         self.assertRaises(ValueError, encode_base_n, 0, 60, custom_table)

  1387. 

  1388.     def test_caesar(self):

  1389.         self.assertEqual(caesar('ace', 'abcdef', 2), 'cea')

  1390.         self.assertEqual(caesar('cea', 'abcdef', -2), 'ace')

  1391.         self.assertEqual(caesar('ace', 'abcdef', -2), 'eac')

  1392.         self.assertEqual(caesar('eac', 'abcdef', 2), 'ace')

  1393.         self.assertEqual(caesar('ace', 'abcdef', 0), 'ace')

  1394.         self.assertEqual(caesar('xyz', 'abcdef', 2), 'xyz')

  1395.         self.assertEqual(caesar('abc', 'acegik', 2), 'ebg')

  1396.         self.assertEqual(caesar('ebg', 'acegik', -2), 'abc')

  1397. 

  1398.     def test_rot47(self):

  1399.         self.assertEqual(rot47('youtube-dl'), r'J@FEF36\5=')

  1400.         self.assertEqual(rot47('YOUTUBE-DL'), r'*~&%&qt\s{')

  1401. 

  1402.     def test_urshift(self):

  1403.         self.assertEqual(urshift(3, 1), 1)

  1404.         self.assertEqual(urshift(-3, 1), 2147483646)

  1405. 

  1406.     def test_get_element_by_class(self):

  1407.         html = '''

  1408.             <span class="foo bar">nice</span>

  1409.         '''

  1410. 

  1411.         self.assertEqual(get_element_by_class('foo', html), 'nice')

  1412.         self.assertEqual(get_element_by_class('no-such-class', html), None)

  1413. 

  1414.     def test_get_element_by_attribute(self):

  1415.         html = '''

  1416.             <span class="foo bar">nice</span>

  1417.         '''

  1418. 

  1419.         self.assertEqual(get_element_by_attribute('class', 'foo bar', html), 'nice')

  1420.         self.assertEqual(get_element_by_attribute('class', 'foo', html), None)

  1421.         self.assertEqual(get_element_by_attribute('class', 'no-such-foo', html), None)

  1422. 

  1423.         html = '''

  1424.             <div itemprop="author" itemscope>foo</div>

  1425.         '''

  1426. 

  1427.         self.assertEqual(get_element_by_attribute('itemprop', 'author', html), 'foo')

  1428. 

  1429.     def test_get_elements_by_class(self):

  1430.         html = '''

  1431.             <span class="foo bar">nice</span><span class="foo bar">also nice</span>

  1432.         '''

  1433. 

  1434.         self.assertEqual(get_elements_by_class('foo', html), ['nice', 'also nice'])

  1435.         self.assertEqual(get_elements_by_class('no-such-class', html), [])

  1436. 

  1437.     def test_get_elements_by_attribute(self):

  1438.         html = '''

  1439.             <span class="foo bar">nice</span><span class="foo bar">also nice</span>

  1440.         '''

  1441. 

  1442.         self.assertEqual(get_elements_by_attribute('class', 'foo bar', html), ['nice', 'also nice'])

  1443.         self.assertEqual(get_elements_by_attribute('class', 'foo', html), [])

  1444.         self.assertEqual(get_elements_by_attribute('class', 'no-such-foo', html), [])

  1445. 

  1446. 

  1447. if __name__ == '__main__':

  1448.     unittest.main()