def test_case():
    """should match books irrespective of case"""
    query_str = 'Matthew'
    results = yvs.get_result_list(query_str)
    results_lower = yvs.get_result_list(query_str.lower())
    results_upper = yvs.get_result_list(query_str.upper())
    nose.assert_equal(len(results), 1)
    nose.assert_list_equal(results_lower, results)
    nose.assert_list_equal(results_upper, results)

def test_case():
    """should match versions irrespective of case"""
    query = 'e 4:8 esv'
    results = yvs.get_result_list(query)
    results_lower = yvs.get_result_list(query.lower())
    results_upper = yvs.get_result_list(query.upper())
    nose.assert_list_equal(results_lower, results)
    nose.assert_list_equal(results_upper, results)
    nose.assert_equal(len(results), 6)

def test_partial_ambiguous():
    """should match books by ambiguous partial name"""
    results = yvs.get_result_list('r')
    nose.assert_equal(len(results), 3)
    nose.assert_equal(results[0]['title'], 'Ruth 1 (NIV)')
    nose.assert_equal(results[1]['title'], 'Romans 1 (NIV)')
    nose.assert_equal(results[2]['title'], 'Revelation 1 (NIV)')

def test_output(out):
    """should output ref result list JSON"""
    query_str = 'genesis 50:20'
    yvs.main(query_str)
    output = out.getvalue().rstrip()
    results = yvs.get_result_list(query_str)
    feedback = yvs.core.get_result_list_feedback_str(results).rstrip()
    nose.assert_equal(output, feedback)

def test_output(out):
    """should output ref result list XML"""
    query_str = 'genesis 50:20'
    yvs.main(query_str)
    output = out.getvalue().strip()
    results = yvs.get_result_list(query_str)
    xml = yvs.shared.get_result_list_xml(results).strip()
    nose.assert_equal(output, xml)

def test_nonnumbered_partial():
    """should match numbered books by partial non-numbered name"""
    results = yvs.get_result_list('john')
    nose.assert_equal(len(results), 4)
    nose.assert_equal(results[0]['title'], 'John 1 (NIV)')
    nose.assert_equal(results[1]['title'], '1 John 1 (NIV)')
    nose.assert_equal(results[2]['title'], '2 John 1 (NIV)')
    nose.assert_equal(results[3]['title'], '3 John 1 (NIV)')

def test_numbered_nonnumbered_partial():
    """should match numbered and non-numbered books by partial name"""
    results = yvs.get_result_list('c')
    nose.assert_equal(results[0]['title'], 'Colossians 1 (NIV)')
    nose.assert_equal(results[1]['title'], '1 Chronicles 1 (NIV)')
    nose.assert_equal(results[2]['title'], '2 Chronicles 1 (NIV)')
    nose.assert_equal(results[3]['title'], '1 Corinthians 1 (NIV)')
    nose.assert_equal(results[4]['title'], '2 Corinthians 1 (NIV)')
    nose.assert_equal(len(results), 5)

def test_structure():
    """JSON should match result list"""
    results = yvs.get_result_list('matthew 6:34')
    result = results[0]
    feedback_str = yvs.core.get_result_list_feedback_str(results)
    feedback = json.loads(feedback_str)
    nose.assert_in('items', feedback, 'feedback object must have result items')
    item = feedback['items'][0]
    nose.assert_equal(item['uid'], result['uid'])
    nose.assert_equal(item['arg'], result['arg'])
    nose.assert_equal(
        item['quicklookurl'], 'https://www.bible.com/bible/111/MAT.6.34')
    nose.assert_equal(item['valid'], True)
    nose.assert_equal(item['title'], 'Matthew 6:34 (NIV)')
    nose.assert_equal(item['text']['copy'], result['title'])
    nose.assert_equal(item['text']['largetype'], result['title'])
    nose.assert_equal(item['subtitle'], result['subtitle'])
    nose.assert_equal(item['icon']['path'], 'icon.png')

def test_structure():
    """XML should match result list"""
    results = yvs.get_result_list('matthew 6:34')
    result = results[0]
    xml = yvs.shared.get_result_list_xml(results)
    root = ET.fromstring(xml)
    nose.assert_equal(root.tag, 'items',
                      'root element must be named <items>')
    item = root.find('item')
    nose.assert_is_not_none(item, '<item> element is missing')
    nose.assert_equal(item.get('uid'), result['uid'])
    nose.assert_equal(item.get('arg'), result['arg'])
    nose.assert_equal(item.get('valid'), 'yes')
    title = item.find('title')
    nose.assert_is_not_none(title, '<title> element is missing')
    copy, largetype = item.findall('text')
    nose.assert_equal(copy.text, result['title'])
    nose.assert_equal(largetype.text, result['title'])
    subtitle = item.find('subtitle')
    nose.assert_is_not_none(subtitle, '<subtitle> element is missing')
    nose.assert_equal(subtitle.text, result['subtitle'])
    icon = item.find('icon')
    nose.assert_is_not_none(icon, '<icon> element is missing')
    nose.assert_equal(icon.text, 'icon.png')

def test_non_ascii():
    """should match versions containing non-ASCII characters"""
    results = yvs.get_result_list('路加 4:8 cunp-上')
    nose.assert_equal(results[0]['title'], '路加福音 4:8 (CUNP-上帝)')
    nose.assert_equal(len(results), 1)

def test_id():
    """should use correct ID for chapters"""
    results = yvs.get_result_list('luke 4')
    nose.assert_equal(results[0]['uid'], 'yvs-111/luk.4')

def test_version():
    """should recognize shorthand version syntax"""
    results = yvs.get_result_list('1 co 13esv')
    nose.assert_equal(results[0]['title'], '1 Corinthians 13 (ESV)')
    nose.assert_equal(len(results), 1)

def test_numbered():
    """should match versions ending in number by partial name"""
    results = yvs.get_result_list('lucas 4:8 rvr1')
    nose.assert_equal(results[0]['title'], 'Lucas 4:8 (RVR1960)')
    nose.assert_equal(len(results), 1)

def test_unicode_normalization():
    """should normalize Unicode characters"""
    results = yvs.get_result_list('e\u0301')
    nose.assert_equal(len(results), 0)

def test_whitespace():
    """should ignore excessive whitespace"""
    results = yvs.get_result_list('  romans  8  28  a  ')
    nose.assert_equal(len(results), 1)
    nose.assert_equal(results[0]['title'], 'Romans 8:28 (AMP)')

def test_trailing_alphanumeric():
    """should ignore trailing non-matching alphanumeric characters"""
    results = yvs.get_result_list('2 co 3 x y z 1 2 3')
    nose.assert_equal(len(results), 1)
    nose.assert_equal(results[0]['title'], '2 Corinthians 3 (NIV)')

def test_unicode_accented():
    """should recognize accented Unicode characters"""
    results = yvs.get_result_list('é 3')
    nose.assert_equal(len(results), 1)
    nose.assert_equal(results[0]['title'], 'Éxodo 3 (NVI)')

def test_nonexistent():
    """should use default version for nonexistent versions with no matches"""
    results = yvs.get_result_list('hosea 6:3 xyz')
    nose.assert_equal(results[0]['title'], 'Hosea 6:3 (NIV)')
    nose.assert_equal(len(results), 1)

def test_version_unicode():
    """should allow shorthand Unicode versions"""
    results = yvs.get_result_list('創世記1:3次經')
    nose.assert_equal(results[0]['title'], '創世記 1:3 (次經)')
    nose.assert_equal(len(results), 1)

def test_partial_ambiguous():
    """should match versions by ambiguous partial name"""
    results = yvs.get_result_list('luke 4:8 c')
    nose.assert_equal(results[0]['title'], 'Luke 4:8 (CEB)')
    nose.assert_equal(len(results), 1)