pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/tests/test_qbasiclexer.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Tests for QBasic
-    ~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import glob
-import os
-import unittest
-
-from pygments.token import Token
-from pygments.lexers.qbasic import QBasicLexer
-
-class QBasicTest(unittest.TestCase):
-    def setUp(self):
-        self.lexer = QBasicLexer()
-        self.maxDiff = None
-
-    def testKeywordsWithDollar(self):
-        fragment = u'DIM x\nx = RIGHT$("abc", 1)\n'
-        expected = [
-            (Token.Keyword.Declaration, u'DIM'),
-            (Token.Text.Whitespace, u' '),
-            (Token.Name.Variable.Global, u'x'),
-            (Token.Text, u'\n'),
-            (Token.Name.Variable.Global, u'x'),
-            (Token.Text.Whitespace, u' '),
-            (Token.Operator, u'='),
-            (Token.Text.Whitespace, u' '),
-            (Token.Keyword.Reserved, u'RIGHT$'),
-            (Token.Punctuation, u'('),
-            (Token.Literal.String.Double, u'"abc"'),
-            (Token.Punctuation, u','),
-            (Token.Text.Whitespace, u' '),
-            (Token.Literal.Number.Integer.Long, u'1'),
-            (Token.Punctuation, u')'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))
-

data/vendor/pygments-main/tests/test_regexlexer.py

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments regex lexer tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import unittest
-
-from pygments.token import Text
-from pygments.lexer import RegexLexer
-from pygments.lexer import bygroups
-from pygments.lexer import default
-
-
-class TestLexer(RegexLexer):
-    """Test tuple state transitions including #pop."""
-    tokens = {
-        'root': [
-            ('a', Text.Root, 'rag'),
-            ('e', Text.Root),
-            default(('beer', 'beer'))
-        ],
-        'beer': [
-            ('d', Text.Beer, ('#pop', '#pop')),
-        ],
-        'rag': [
-            ('b', Text.Rag, '#push'),
-            ('c', Text.Rag, ('#pop', 'beer')),
-        ],
-    }
-
-
-class TupleTransTest(unittest.TestCase):
-    def test(self):
-        lx = TestLexer()
-        toks = list(lx.get_tokens_unprocessed('abcde'))
-        self.assertEqual(toks,
-           [(0, Text.Root, 'a'), (1, Text.Rag, 'b'), (2, Text.Rag, 'c'),
-            (3, Text.Beer, 'd'), (4, Text.Root, 'e')])
-
-    def test_multiline(self):
-        lx = TestLexer()
-        toks = list(lx.get_tokens_unprocessed('a\ne'))
-        self.assertEqual(toks,
-           [(0, Text.Root, 'a'), (1, Text, u'\n'),
-            (2, Text.Root, 'e')])
-
-    def test_default(self):
-        lx = TestLexer()
-        toks = list(lx.get_tokens_unprocessed('d'))
-        self.assertEqual(toks, [(0, Text.Beer, 'd')])

data/vendor/pygments-main/tests/test_rtf_formatter.py

@@ -1,109 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments RTF formatter tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import unittest
-from string_asserts import StringTests
-
-from pygments.util import StringIO
-from pygments.formatters import RtfFormatter
-from pygments.lexers.special import TextLexer
-
-class RtfFormatterTest(StringTests, unittest.TestCase):
-    foot = (r'\par' '\n' r'}')
-
-    def _escape(self, string):
-        return(string.replace("\n", r"\n"))
-
-    def _build_message(self, *args, **kwargs):
-        string = kwargs.get('string', None)
-        t = self._escape(kwargs.get('t', ''))
-        expected = self._escape(kwargs.get('expected', ''))
-        result = self._escape(kwargs.get('result', ''))
-
-        if string is None:
-            string = (u"The expected output of '{t}'\n"
-                      u"\t\tShould be '{expected}'\n"
-                      u"\t\tActually outputs '{result}'\n"
-                      u"\t(WARNING: Partial Output of Result!)")
-
-        end = -(len(self._escape(self.foot)))
-        start = end-len(expected)
-
-        return string.format(t=t,
-                             result = result[start:end],
-                             expected = expected)
-
-    def format_rtf(self, t):
-        tokensource = list(TextLexer().get_tokens(t))
-        fmt = RtfFormatter()
-        buf = StringIO()
-        fmt.format(tokensource, buf)
-        result = buf.getvalue()
-        buf.close()
-        return result
-
-    def test_rtf_header(self):
-        t = u''
-        result = self.format_rtf(t)
-        expected = r'{\rtf1\ansi\uc0'
-        msg = (u"RTF documents are expected to start with '{expected}'\n"
-               u"\t\tStarts intead with '{result}'\n"
-               u"\t(WARNING: Partial Output of Result!)".format(
-                   expected = expected,
-                   result = result[:len(expected)]))
-        self.assertStartsWith(result, expected, msg)
-
-    def test_rtf_footer(self):
-        t = u''
-        result = self.format_rtf(t)
-        expected = self.foot
-        msg = (u"RTF documents are expected to end with '{expected}'\n"
-               u"\t\tEnds intead with '{result}'\n"
-               u"\t(WARNING: Partial Output of Result!)".format(
-                   expected = self._escape(expected),
-                   result = self._escape(result[-len(expected):])))
-        self.assertEndsWith(result, expected, msg)
-
-    def test_ascii_characters(self):
-        t = u'a b c d ~'
-        result = self.format_rtf(t)
-        expected = (r'a b c d ~')
-        if not result.endswith(self.foot):
-            return(unittest.skip('RTF Footer incorrect'))
-        msg = self._build_message(t=t, result=result, expected=expected)
-        self.assertEndsWith(result, expected+self.foot, msg)
-
-    def test_escape_characters(self):
-        t = u'\ {{'
-        result = self.format_rtf(t)
-        expected = (r'\\ \{\{')
-        if not result.endswith(self.foot):
-            return(unittest.skip('RTF Footer incorrect'))
-        msg = self._build_message(t=t, result=result, expected=expected)
-        self.assertEndsWith(result, expected+self.foot, msg)
-
-    def test_single_characters(self):
-        t = u'â € ¤ каждой'
-        result = self.format_rtf(t)
-        expected = (r'{\u226} {\u8364} {\u164} '
-                    r'{\u1082}{\u1072}{\u1078}{\u1076}{\u1086}{\u1081}')
-        if not result.endswith(self.foot):
-            return(unittest.skip('RTF Footer incorrect'))
-        msg = self._build_message(t=t, result=result, expected=expected)
-        self.assertEndsWith(result, expected+self.foot, msg)
-
-    def test_double_characters(self):
-        t = u'က 힣 ↕ ↕︎ 鼖'
-        result = self.format_rtf(t)
-        expected = (r'{\u4096} {\u55203} {\u8597} '
-                    r'{\u8597}{\u65038} {\u55422}{\u56859}')
-        if not result.endswith(self.foot):
-            return(unittest.skip('RTF Footer incorrect'))
-        msg = self._build_message(t=t, result=result, expected=expected)
-        self.assertEndsWith(result, expected+self.foot, msg)

data/vendor/pygments-main/tests/test_string_asserts.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments string assert utility tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import unittest
-from string_asserts import StringTests
-
-class TestStringTests(StringTests, unittest.TestCase):
-
-    def test_startswith_correct(self):
-        self.assertStartsWith("AAA", "A")
-
-    # @unittest.expectedFailure not supported by nose
-    def test_startswith_incorrect(self):
-        with self.assertRaises(AssertionError):
-            self.assertStartsWith("AAA", "B")
-
-    # @unittest.expectedFailure not supported by nose
-    def test_startswith_short(self):
-        with self.assertRaises(AssertionError):
-            self.assertStartsWith("A", "AA")
-
-    def test_endswith_correct(self):
-        self.assertEndsWith("AAA", "A")
-
-    # @unittest.expectedFailure not supported by nose
-    def test_endswith_incorrect(self):
-        with self.assertRaises(AssertionError):
-            self.assertEndsWith("AAA", "B")
-
-    # @unittest.expectedFailure not supported by nose
-    def test_endswith_short(self):
-        with self.assertRaises(AssertionError):
-            self.assertEndsWith("A", "AA")

data/vendor/pygments-main/tests/test_token.py

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Test suite for the token module
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import unittest
-
-from pygments import token
-
-
-class TokenTest(unittest.TestCase):
-
-    def test_tokentype(self):
-        e = self.assertEqual
-
-        t = token.String
-
-        e(t.split(), [token.Token, token.Literal, token.String])
-
-        e(t.__class__, token._TokenType)
-
-    def test_functions(self):
-        self.assertTrue(token.is_token_subtype(token.String, token.String))
-        self.assertTrue(token.is_token_subtype(token.String, token.Literal))
-        self.assertFalse(token.is_token_subtype(token.Literal, token.String))
-
-        self.assertTrue(token.string_to_tokentype(token.String) is token.String)
-        self.assertTrue(token.string_to_tokentype('') is token.Token)
-        self.assertTrue(token.string_to_tokentype('String') is token.String)
-
-    def test_sanity_check(self):
-        stp = token.STANDARD_TYPES.copy()
-        stp[token.Token] = '---' # Token and Text do conflict, that is okay
-        t = {}
-        for k, v in stp.items():
-            t.setdefault(v, []).append(k)
-        if len(t) == len(stp):
-            return # Okay
-
-        for k, v in t.items():
-            if len(v) > 1:
-                self.fail("%r has more than one key: %r" % (k, v))

data/vendor/pygments-main/tests/test_using_api.py

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments tests for using()
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import unittest
-
-from pygments.lexer import using, bygroups, this, RegexLexer
-from pygments.token import String, Text, Keyword
-
-class TestLexer(RegexLexer):
-    tokens = {
-        'root': [
-            (r'#.*',
-             using(this, state='invalid')),
-            (r'(")(.+?)(")',
-             bygroups(String, using(this, state='string'), String)),
-            (r'[^"]+', Text),
-        ],
-        'string': [
-            (r'.+', Keyword),
-        ],
-    }
-
-
-class UsingStateTest(unittest.TestCase):
-    def test_basic(self):
-        expected = [(Text, 'a'), (String, '"'), (Keyword, 'bcd'),
-                    (String, '"'), (Text, 'e\n')]
-        t = list(TestLexer().get_tokens('a"bcd"e'))
-        self.assertEqual(t, expected)
-
-    def test_error(self):
-        def gen():
-            return list(TestLexer().get_tokens('#a'))
-        self.assertRaises(KeyError, gen)

data/vendor/pygments-main/tests/test_util.py

@@ -1,135 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Test suite for the util module
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import re
-import unittest
-
-from pygments import util
-
-
-class FakeLexer(object):
-    def analyse(text):
-        return float(text)
-    analyse = util.make_analysator(analyse)
-
-
-class UtilTest(unittest.TestCase):
-
-    def test_getoptions(self):
-        raises = self.assertRaises
-        equals = self.assertEqual
-
-        equals(util.get_bool_opt({}, 'a', True), True)
-        equals(util.get_bool_opt({}, 'a', 1), True)
-        equals(util.get_bool_opt({}, 'a', 'true'), True)
-        equals(util.get_bool_opt({}, 'a', 'no'), False)
-        raises(util.OptionError, util.get_bool_opt, {}, 'a', [])
-        raises(util.OptionError, util.get_bool_opt, {}, 'a', 'foo')
-
-        equals(util.get_int_opt({}, 'a', 1), 1)
-        raises(util.OptionError, util.get_int_opt, {}, 'a', [])
-        raises(util.OptionError, util.get_int_opt, {}, 'a', 'bar')
-
-        equals(util.get_list_opt({}, 'a', [1]), [1])
-        equals(util.get_list_opt({}, 'a', '1 2'), ['1', '2'])
-        raises(util.OptionError, util.get_list_opt, {}, 'a', 1)
-
-
-    def test_docstring_headline(self):
-        def f1():
-            """
-            docstring headline
-
-            other text
-            """
-        def f2():
-            """
-            docstring
-            headline
-
-            other text
-            """
-
-        self.assertEqual(util.docstring_headline(f1), "docstring headline")
-        self.assertEqual(util.docstring_headline(f2), "docstring headline")
-
-    def test_analysator_returns_float(self):
-        # If an analysator wrapped by make_analysator returns a floating point
-        # number, then that number will be returned by the wrapper.
-        self.assertEqual(FakeLexer.analyse('0.5'), 0.5)
-
-    def test_analysator_returns_boolean(self):
-        # If an analysator wrapped by make_analysator returns a boolean value,
-        # then the wrapper will return 1.0 if the boolean was True or 0.0 if
-        # it was False.
-        self.assertEqual(FakeLexer.analyse(True), 1.0)
-        self.assertEqual(FakeLexer.analyse(False), 0.0)
-
-    def test_analysator_raises_exception(self):
-        # If an analysator wrapped by make_analysator raises an exception,
-        # then the wrapper will return 0.0.
-        class ErrorLexer(object):
-            def analyse(text):
-                raise RuntimeError('something bad happened')
-            analyse = util.make_analysator(analyse)
-        self.assertEqual(ErrorLexer.analyse(''), 0.0)
-
-    def test_analysator_value_error(self):
-        # When converting the analysator's return value to a float a
-        # ValueError may occur.  If that happens 0.0 is returned instead.
-        self.assertEqual(FakeLexer.analyse('bad input'), 0.0)
-
-    def test_analysator_type_error(self):
-        # When converting the analysator's return value to a float a
-        # TypeError may occur.  If that happens 0.0 is returned instead.
-        self.assertEqual(FakeLexer.analyse(None), 0.0)
-
-    def test_shebang_matches(self):
-        self.assertTrue(util.shebang_matches('#!/usr/bin/env python', r'python(2\.\d)?'))
-        self.assertTrue(util.shebang_matches('#!/usr/bin/python2.4', r'python(2\.\d)?'))
-        self.assertTrue(util.shebang_matches('#!/usr/bin/startsomethingwith python',
-                                             r'python(2\.\d)?'))
-        self.assertTrue(util.shebang_matches('#!C:\\Python2.4\\Python.exe',
-                                             r'python(2\.\d)?'))
-
-        self.assertFalse(util.shebang_matches('#!/usr/bin/python-ruby',
-                                              r'python(2\.\d)?'))
-        self.assertFalse(util.shebang_matches('#!/usr/bin/python/ruby',
-                                              r'python(2\.\d)?'))
-        self.assertFalse(util.shebang_matches('#!', r'python'))
-
-    def test_doctype_matches(self):
-        self.assertTrue(util.doctype_matches(
-            '<!DOCTYPE html PUBLIC "a"> <html>', 'html.*'))
-        self.assertFalse(util.doctype_matches(
-            '<?xml ?> <DOCTYPE html PUBLIC "a"> <html>', 'html.*'))
-        self.assertTrue(util.html_doctype_matches(
-            '<?xml ?><!DOCTYPE html PUBLIC  "-//W3C//DTD XHTML 1.0 Strict//EN">'))
-
-    def test_xml(self):
-        self.assertTrue(util.looks_like_xml(
-            '<?xml ?><!DOCTYPE html PUBLIC  "-//W3C//DTD XHTML 1.0 Strict//EN">'))
-        self.assertTrue(util.looks_like_xml('<html xmlns>abc</html>'))
-        self.assertFalse(util.looks_like_xml('<html>'))
-
-    def test_unirange(self):
-        first_non_bmp = u'\U00010000'
-        r = re.compile(util.unirange(0x10000, 0x20000))
-        m = r.match(first_non_bmp)
-        self.assertTrue(m)
-        self.assertEquals(m.end(), len(first_non_bmp))
-        self.assertFalse(r.match(u'\uffff'))
-        self.assertFalse(r.match(u'xxx'))
-        # Tests that end is inclusive
-        r = re.compile(util.unirange(0x10000, 0x10000) + '+')
-        # Tests that the plus works for the entire unicode point, if narrow
-        # build
-        m = r.match(first_non_bmp * 2)
-        self.assertTrue(m)
-        self.assertEquals(m.end(), len(first_non_bmp) * 2)