Exemple #1
0
def IsIdentifier_TypeScript_test():
  ok_( iu.IsIdentifier( '_føo1', 'typescript' ) )
  ok_( iu.IsIdentifier( 'fø_o1', 'typescript' ) )
  ok_( iu.IsIdentifier( '$føo1', 'typescript' ) )
  ok_( iu.IsIdentifier( 'fø$o1', 'typescript' ) )

  ok_( not iu.IsIdentifier( '1føo', 'typescript' ) )
def IsIdentifier_TypeScript_test():
  assert_that( iu.IsIdentifier( '_føo1', 'typescript' ) )
  assert_that( iu.IsIdentifier( 'fø_o1', 'typescript' ) )
  assert_that( iu.IsIdentifier( '$føo1', 'typescript' ) )
  assert_that( iu.IsIdentifier( 'fø$o1', 'typescript' ) )

  assert_that( not iu.IsIdentifier( '1føo', 'typescript' ) )
Exemple #3
0
def IsIdentifier_JavaScript_test():
  ok_( iu.IsIdentifier( '_føo1', 'javascript' ) )
  ok_( iu.IsIdentifier( 'fø_o1', 'javascript' ) )
  ok_( iu.IsIdentifier( '$føo1', 'javascript' ) )
  ok_( iu.IsIdentifier( 'fø$o1', 'javascript' ) )

  ok_( not iu.IsIdentifier( '1føo', 'javascript' ) )
def IsIdentifier_JavaScript_test():
  assert_that( iu.IsIdentifier( '_føo1', 'javascript' ) )
  assert_that( iu.IsIdentifier( 'fø_o1', 'javascript' ) )
  assert_that( iu.IsIdentifier( '$føo1', 'javascript' ) )
  assert_that( iu.IsIdentifier( 'fø$o1', 'javascript' ) )

  assert_that( not iu.IsIdentifier( '1føo', 'javascript' ) )
Exemple #5
0
def IsIdentifier_Haskell_test():
    ok_(iu.IsIdentifier('foo', 'haskell'))
    ok_(iu.IsIdentifier("foo'", 'haskell'))
    ok_(iu.IsIdentifier("x'", 'haskell'))
    ok_(iu.IsIdentifier("_x'", 'haskell'))
    ok_(iu.IsIdentifier("_x", 'haskell'))
    ok_(iu.IsIdentifier("x9", 'haskell'))

    ok_(not iu.IsIdentifier("'x", 'haskell'))
    ok_(not iu.IsIdentifier("9x", 'haskell'))
    ok_(not iu.IsIdentifier("9", 'haskell'))
    ok_(not iu.IsIdentifier('', 'haskell'))
def IsIdentifier_Haskell_test():
  assert_that( iu.IsIdentifier( 'foo' , 'haskell' ) )
  assert_that( iu.IsIdentifier( "foo'", 'haskell' ) )
  assert_that( iu.IsIdentifier( "x'"  , 'haskell' ) )
  assert_that( iu.IsIdentifier( "_x'" , 'haskell' ) )
  assert_that( iu.IsIdentifier( "_x"  , 'haskell' ) )
  assert_that( iu.IsIdentifier( "x9"  , 'haskell' ) )

  assert_that( not iu.IsIdentifier( "'x", 'haskell' ) )
  assert_that( not iu.IsIdentifier( "9x", 'haskell' ) )
  assert_that( not iu.IsIdentifier( "9" , 'haskell' ) )
  assert_that( not iu.IsIdentifier( ''  , 'haskell' ) )
def IsIdentifier_generic_test():
    ok_(iu.IsIdentifier('foo'))
    ok_(iu.IsIdentifier('foo129'))
    ok_(iu.IsIdentifier('f12'))

    ok_(not iu.IsIdentifier('1foo129'))
    ok_(not iu.IsIdentifier('-foo'))
    ok_(not iu.IsIdentifier('foo-'))
    ok_(not iu.IsIdentifier('font-face'))
    ok_(not iu.IsIdentifier(None))
    ok_(not iu.IsIdentifier(''))
Exemple #8
0
def IsIdentifier_Elisp_test():
    # elisp is using the clojure regexes, so we're testing this more lightly
    ok_(iu.IsIdentifier('foo', 'elisp'))
    ok_(iu.IsIdentifier('f9', 'elisp'))
    ok_(iu.IsIdentifier('a.b.c', 'elisp'))
    ok_(iu.IsIdentifier('a/c', 'elisp'))

    ok_(not iu.IsIdentifier('9f', 'elisp'))
    ok_(not iu.IsIdentifier('9', 'elisp'))
    ok_(not iu.IsIdentifier('a/b/c', 'elisp'))
    ok_(not iu.IsIdentifier('(a)', 'elisp'))
    ok_(not iu.IsIdentifier('', 'elisp'))
Exemple #9
0
    def test_IsIdentifier_Elisp(self):
        # elisp is using the clojure regexes, so we're testing this more lightly
        assert_that(iu.IsIdentifier('foo', 'elisp'))
        assert_that(iu.IsIdentifier('f9', 'elisp'))
        assert_that(iu.IsIdentifier('a.b.c', 'elisp'))
        assert_that(iu.IsIdentifier('a/c', 'elisp'))

        assert_that(not iu.IsIdentifier('9f', 'elisp'))
        assert_that(not iu.IsIdentifier('9', 'elisp'))
        assert_that(not iu.IsIdentifier('a/b/c', 'elisp'))
        assert_that(not iu.IsIdentifier('(a)', 'elisp'))
        assert_that(not iu.IsIdentifier('', 'elisp'))
Exemple #10
0
def IsIdentifier_Tex_test():
    ok_(iu.IsIdentifier('foo', 'tex'))
    ok_(iu.IsIdentifier('fig:foo', 'tex'))
    ok_(iu.IsIdentifier('fig:foo-bar', 'tex'))
    ok_(iu.IsIdentifier('sec:summary', 'tex'))
    ok_(iu.IsIdentifier('eq:bar_foo', 'tex'))

    ok_(not iu.IsIdentifier('\section', 'tex'))
    ok_(not iu.IsIdentifier('some8', 'tex'))
    ok_(not iu.IsIdentifier('', 'tex'))
Exemple #11
0
def LastTriggerLineAndColumn():
    line, column = CurrentLineAndColumn()
    line_value = vim.current.line[:column].rstrip()
    while not line_value:
        line = line - 1
        if line == -1:
            return CurrentLineAndColumn()
        line_value = vim.current.buffer[line].rstrip()
    column = len(line_value)
    filetypes = CurrentFiletypes()
    filetype = filetypes[0] if filetypes else None
    if identifier_utils.IsIdentifier(vim.current.buffer[line][column - 1],
                                     filetype):
        return CurrentLineAndColumn()
    return line, column
Exemple #12
0
def IsIdentifier_Perl6_test():
    ok_(iu.IsIdentifier('foo', 'perl6'))
    ok_(iu.IsIdentifier("f-o", 'perl6'))
    ok_(iu.IsIdentifier("x'y", 'perl6'))
    ok_(iu.IsIdentifier("_x-y", 'perl6'))
    ok_(iu.IsIdentifier("x-y'a", 'perl6'))
    ok_(iu.IsIdentifier("x-_", 'perl6'))
    ok_(iu.IsIdentifier("x-_7", 'perl6'))
    ok_(iu.IsIdentifier("_x", 'perl6'))
    ok_(iu.IsIdentifier("x9", 'perl6'))

    ok_(not iu.IsIdentifier("'x", 'perl6'))
    ok_(not iu.IsIdentifier("x'", 'perl6'))
    ok_(not iu.IsIdentifier("-x", 'perl6'))
    ok_(not iu.IsIdentifier("x-", 'perl6'))
    ok_(not iu.IsIdentifier("x-1", 'perl6'))
    ok_(not iu.IsIdentifier("x--", 'perl6'))
    ok_(not iu.IsIdentifier("x--a", 'perl6'))
    ok_(not iu.IsIdentifier("x-'", 'perl6'))
    ok_(not iu.IsIdentifier("x-'a", 'perl6'))
    ok_(not iu.IsIdentifier("x-a-", 'perl6'))
    ok_(not iu.IsIdentifier("x+", 'perl6'))
    ok_(not iu.IsIdentifier("9x", 'perl6'))
    ok_(not iu.IsIdentifier("9", 'perl6'))
    ok_(not iu.IsIdentifier('', 'perl6'))
Exemple #13
0
    def test_IsIdentifier_Perl6(self):
        assert_that(iu.IsIdentifier('foo', 'perl6'))
        assert_that(iu.IsIdentifier("f-o", 'perl6'))
        assert_that(iu.IsIdentifier("x'y", 'perl6'))
        assert_that(iu.IsIdentifier("_x-y", 'perl6'))
        assert_that(iu.IsIdentifier("x-y'a", 'perl6'))
        assert_that(iu.IsIdentifier("x-_", 'perl6'))
        assert_that(iu.IsIdentifier("x-_7", 'perl6'))
        assert_that(iu.IsIdentifier("_x", 'perl6'))
        assert_that(iu.IsIdentifier("x9", 'perl6'))

        assert_that(not iu.IsIdentifier("'x", 'perl6'))
        assert_that(not iu.IsIdentifier("x'", 'perl6'))
        assert_that(not iu.IsIdentifier("-x", 'perl6'))
        assert_that(not iu.IsIdentifier("x-", 'perl6'))
        assert_that(not iu.IsIdentifier("x-1", 'perl6'))
        assert_that(not iu.IsIdentifier("x--", 'perl6'))
        assert_that(not iu.IsIdentifier("x--a", 'perl6'))
        assert_that(not iu.IsIdentifier("x-'", 'perl6'))
        assert_that(not iu.IsIdentifier("x-'a", 'perl6'))
        assert_that(not iu.IsIdentifier("x-a-", 'perl6'))
        assert_that(not iu.IsIdentifier("x+", 'perl6'))
        assert_that(not iu.IsIdentifier("9x", 'perl6'))
        assert_that(not iu.IsIdentifier("9", 'perl6'))
        assert_that(not iu.IsIdentifier('', 'perl6'))
Exemple #14
0
    def test_IsIdentifier_Clojure(self):
        assert_that(iu.IsIdentifier('foo', 'clojure'))
        assert_that(iu.IsIdentifier('f9', 'clojure'))
        assert_that(iu.IsIdentifier('a.b.c', 'clojure'))
        assert_that(iu.IsIdentifier('a.c', 'clojure'))
        assert_that(iu.IsIdentifier('a/c', 'clojure'))
        assert_that(iu.IsIdentifier('*', 'clojure'))
        assert_that(iu.IsIdentifier('a*b', 'clojure'))
        assert_that(iu.IsIdentifier('?', 'clojure'))
        assert_that(iu.IsIdentifier('a?b', 'clojure'))
        assert_that(iu.IsIdentifier(':', 'clojure'))
        assert_that(iu.IsIdentifier('a:b', 'clojure'))
        assert_that(iu.IsIdentifier('+', 'clojure'))
        assert_that(iu.IsIdentifier('a+b', 'clojure'))
        assert_that(iu.IsIdentifier('-', 'clojure'))
        assert_that(iu.IsIdentifier('a-b', 'clojure'))
        assert_that(iu.IsIdentifier('!', 'clojure'))
        assert_that(iu.IsIdentifier('a!b', 'clojure'))

        assert_that(not iu.IsIdentifier('9f', 'clojure'))
        assert_that(not iu.IsIdentifier('9', 'clojure'))
        assert_that(not iu.IsIdentifier('a/b/c', 'clojure'))
        assert_that(not iu.IsIdentifier('(a)', 'clojure'))
        assert_that(not iu.IsIdentifier('', 'clojure'))
Exemple #15
0
def IsIdentifier_Clojure_test():
    ok_(iu.IsIdentifier('foo', 'clojure'))
    ok_(iu.IsIdentifier('f9', 'clojure'))
    ok_(iu.IsIdentifier('a.b.c', 'clojure'))
    ok_(iu.IsIdentifier('a.c', 'clojure'))
    ok_(iu.IsIdentifier('a/c', 'clojure'))
    ok_(iu.IsIdentifier('*', 'clojure'))
    ok_(iu.IsIdentifier('a*b', 'clojure'))
    ok_(iu.IsIdentifier('?', 'clojure'))
    ok_(iu.IsIdentifier('a?b', 'clojure'))
    ok_(iu.IsIdentifier(':', 'clojure'))
    ok_(iu.IsIdentifier('a:b', 'clojure'))
    ok_(iu.IsIdentifier('+', 'clojure'))
    ok_(iu.IsIdentifier('a+b', 'clojure'))
    ok_(iu.IsIdentifier('-', 'clojure'))
    ok_(iu.IsIdentifier('a-b', 'clojure'))
    ok_(iu.IsIdentifier('!', 'clojure'))
    ok_(iu.IsIdentifier('a!b', 'clojure'))

    ok_(not iu.IsIdentifier('9f', 'clojure'))
    ok_(not iu.IsIdentifier('9', 'clojure'))
    ok_(not iu.IsIdentifier('a/b/c', 'clojure'))
    ok_(not iu.IsIdentifier('(a)', 'clojure'))
    ok_(not iu.IsIdentifier('', 'clojure'))
Exemple #16
0
    def test_IsIdentifier_Scheme(self):
        assert_that(iu.IsIdentifier('λ', 'scheme'))
        assert_that(iu.IsIdentifier('_', 'scheme'))
        assert_that(iu.IsIdentifier('+', 'scheme'))
        assert_that(iu.IsIdentifier('-', 'scheme'))
        assert_that(iu.IsIdentifier('...', 'scheme'))
        assert_that(iu.IsIdentifier(r'\x01;', 'scheme'))
        assert_that(iu.IsIdentifier(r'h\x65;lle', 'scheme'))
        assert_that(iu.IsIdentifier('foo', 'scheme'))
        assert_that(iu.IsIdentifier('foo+-*/1-1', 'scheme'))
        assert_that(iu.IsIdentifier('call/cc', 'scheme'))

        assert_that(not iu.IsIdentifier('.', 'scheme'))
        assert_that(not iu.IsIdentifier('..', 'scheme'))
        assert_that(not iu.IsIdentifier('--', 'scheme'))
        assert_that(not iu.IsIdentifier('++', 'scheme'))
        assert_that(not iu.IsIdentifier('+1', 'scheme'))
        assert_that(not iu.IsIdentifier('-1', 'scheme'))
        assert_that(not iu.IsIdentifier('-abc', 'scheme'))
        assert_that(not iu.IsIdentifier('-<abc', 'scheme'))
        assert_that(not iu.IsIdentifier('@', 'scheme'))
        assert_that(not iu.IsIdentifier('@a', 'scheme'))
        assert_that(not iu.IsIdentifier('-@a', 'scheme'))
        assert_that(not iu.IsIdentifier('-12a', 'scheme'))
        assert_that(not iu.IsIdentifier('12a', 'scheme'))
        assert_that(not iu.IsIdentifier('\\', 'scheme'))
        assert_that(not iu.IsIdentifier(r'\x', 'scheme'))
        assert_that(not iu.IsIdentifier(r'\x123', 'scheme'))
        assert_that(not iu.IsIdentifier(r'aa\x123;cc\x', 'scheme'))
Exemple #17
0
def IsIdentifier_Css_test():
    ok_(iu.IsIdentifier('foo', 'css'))
    ok_(iu.IsIdentifier('a1', 'css'))
    ok_(iu.IsIdentifier('a-', 'css'))
    ok_(iu.IsIdentifier('a-b', 'css'))
    ok_(iu.IsIdentifier('_b', 'css'))
    ok_(iu.IsIdentifier('-ms-foo', 'css'))
    ok_(iu.IsIdentifier('-_o', 'css'))
    ok_(iu.IsIdentifier('font-face', 'css'))

    ok_(not iu.IsIdentifier('-3b', 'css'))
    ok_(not iu.IsIdentifier('-3', 'css'))
    ok_(not iu.IsIdentifier('3', 'css'))
    ok_(not iu.IsIdentifier('a', 'css'))
    ok_(not iu.IsIdentifier('', 'css'))
Exemple #18
0
def IsIdentifier_R_test():
    ok_(iu.IsIdentifier('a', 'r'))
    ok_(iu.IsIdentifier('a.b', 'r'))
    ok_(iu.IsIdentifier('a.b.c', 'r'))
    ok_(iu.IsIdentifier('a_b', 'r'))
    ok_(iu.IsIdentifier('a1', 'r'))
    ok_(iu.IsIdentifier('a_1', 'r'))
    ok_(iu.IsIdentifier('.a', 'r'))
    ok_(iu.IsIdentifier('.a_b', 'r'))
    ok_(iu.IsIdentifier('.a1', 'r'))
    ok_(iu.IsIdentifier('...', 'r'))
    ok_(iu.IsIdentifier('..1', 'r'))

    ok_(not iu.IsIdentifier('.1a', 'r'))
    ok_(not iu.IsIdentifier('.1', 'r'))
    ok_(not iu.IsIdentifier('1a', 'r'))
    ok_(not iu.IsIdentifier('123', 'r'))
    ok_(not iu.IsIdentifier('_1a', 'r'))
    ok_(not iu.IsIdentifier('_a', 'r'))
    ok_(not iu.IsIdentifier('', 'r'))
Exemple #19
0
def IsIdentifier_generic_unicode_single_char_test():
    ok_(iu.IsIdentifier('ç'))
Exemple #20
0
def IsIdentifier_generic_unicode_char_first_test():
    ok_(iu.IsIdentifier('çode'))
def IsIdentifier_Css_test():
  assert_that( iu.IsIdentifier( 'foo'      , 'css' ) )
  assert_that( iu.IsIdentifier( 'a'        , 'css' ) )
  assert_that( iu.IsIdentifier( 'a1'       , 'css' ) )
  assert_that( iu.IsIdentifier( 'a-'       , 'css' ) )
  assert_that( iu.IsIdentifier( 'a-b'      , 'css' ) )
  assert_that( iu.IsIdentifier( '_b'       , 'css' ) )
  assert_that( iu.IsIdentifier( '-ms-foo'  , 'css' ) )
  assert_that( iu.IsIdentifier( '-_o'      , 'css' ) )
  assert_that( iu.IsIdentifier( 'font-face', 'css' ) )
  assert_that( iu.IsIdentifier( 'αβγ'      , 'css' ) )

  assert_that( not iu.IsIdentifier( '-3b', 'css' ) )
  assert_that( not iu.IsIdentifier( '-3' , 'css' ) )
  assert_that( not iu.IsIdentifier( '--' , 'css' ) )
  assert_that( not iu.IsIdentifier( '3'  , 'css' ) )
  assert_that( not iu.IsIdentifier( ''   , 'css' ) )
  assert_that( not iu.IsIdentifier( '€'  , 'css' ) )
Exemple #22
0
def IsIdentifier_generic_unicode_test():
    ok_(iu.IsIdentifier('uniçode'))
    ok_(iu.IsIdentifier('uç'))
Exemple #23
0
def IsIdentifier_Scheme_test():
  ok_( iu.IsIdentifier( 'λ'         , 'scheme' ) )
  ok_( iu.IsIdentifier( '_'         , 'scheme' ) )
  ok_( iu.IsIdentifier( '+'         , 'scheme' ) )
  ok_( iu.IsIdentifier( '-'         , 'scheme' ) )
  ok_( iu.IsIdentifier( '...'       , 'scheme' ) )
  ok_( iu.IsIdentifier( r'\x01;'    , 'scheme' ) )
  ok_( iu.IsIdentifier( r'h\x65;lle', 'scheme' ) )
  ok_( iu.IsIdentifier( 'foo'       , 'scheme' ) )
  ok_( iu.IsIdentifier( 'foo+-*/1-1', 'scheme' ) )
  ok_( iu.IsIdentifier( 'call/cc'   , 'scheme' ) )

  ok_( not iu.IsIdentifier( '.'            , 'scheme' ) )
  ok_( not iu.IsIdentifier( '..'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( '--'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( '++'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( '+1'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( '-1'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( '-abc'         , 'scheme' ) )
  ok_( not iu.IsIdentifier( '-<abc'        , 'scheme' ) )
  ok_( not iu.IsIdentifier( '@'            , 'scheme' ) )
  ok_( not iu.IsIdentifier( '@a'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( '-@a'          , 'scheme' ) )
  ok_( not iu.IsIdentifier( '-12a'         , 'scheme' ) )
  ok_( not iu.IsIdentifier( '12a'          , 'scheme' ) )
  ok_( not iu.IsIdentifier( '\\'           , 'scheme' ) )
  ok_( not iu.IsIdentifier( r'\x'          , 'scheme' ) )
  ok_( not iu.IsIdentifier( r'\x123'       , 'scheme' ) )
  ok_( not iu.IsIdentifier( r'aa\x123;cc\x', 'scheme' ) )
def IsIdentifier_R_test():
  assert_that( iu.IsIdentifier( 'a'    , 'r' ) )
  assert_that( iu.IsIdentifier( 'a.b'  , 'r' ) )
  assert_that( iu.IsIdentifier( 'a.b.c', 'r' ) )
  assert_that( iu.IsIdentifier( 'a_b'  , 'r' ) )
  assert_that( iu.IsIdentifier( 'a1'   , 'r' ) )
  assert_that( iu.IsIdentifier( 'a_1'  , 'r' ) )
  assert_that( iu.IsIdentifier( '.a'   , 'r' ) )
  assert_that( iu.IsIdentifier( '.a_b' , 'r' ) )
  assert_that( iu.IsIdentifier( '.a1'  , 'r' ) )
  assert_that( iu.IsIdentifier( '...'  , 'r' ) )
  assert_that( iu.IsIdentifier( '..1'  , 'r' ) )

  assert_that( not iu.IsIdentifier( '.1a', 'r' ) )
  assert_that( not iu.IsIdentifier( '.1' , 'r' ) )
  assert_that( not iu.IsIdentifier( '1a' , 'r' ) )
  assert_that( not iu.IsIdentifier( '123', 'r' ) )
  assert_that( not iu.IsIdentifier( '_1a', 'r' ) )
  assert_that( not iu.IsIdentifier( '_a' , 'r' ) )
  assert_that( not iu.IsIdentifier( ''   , 'r' ) )
Exemple #25
0
    def test_IsIdentifier_Default(self):
        assert_that(iu.IsIdentifier('foo'))
        assert_that(iu.IsIdentifier('foo129'))
        assert_that(iu.IsIdentifier('f12'))
        assert_that(iu.IsIdentifier('f12'))

        assert_that(iu.IsIdentifier('_foo'))
        assert_that(iu.IsIdentifier('_foo129'))
        assert_that(iu.IsIdentifier('_f12'))
        assert_that(iu.IsIdentifier('_f12'))

        assert_that(iu.IsIdentifier('uniçode'))
        assert_that(iu.IsIdentifier('uç'))
        assert_that(iu.IsIdentifier('ç'))
        assert_that(iu.IsIdentifier('çode'))

        assert_that(not iu.IsIdentifier('1foo129'))
        assert_that(not iu.IsIdentifier('-foo'))
        assert_that(not iu.IsIdentifier('foo-'))
        assert_that(not iu.IsIdentifier('font-face'))
        assert_that(not iu.IsIdentifier(None))
        assert_that(not iu.IsIdentifier(''))
Exemple #26
0
def IsIdentifier_Default_test():
  ok_( iu.IsIdentifier( 'foo' ) )
  ok_( iu.IsIdentifier( 'foo129' ) )
  ok_( iu.IsIdentifier( 'f12' ) )
  ok_( iu.IsIdentifier( 'f12' ) )

  ok_( iu.IsIdentifier( '_foo' ) )
  ok_( iu.IsIdentifier( '_foo129' ) )
  ok_( iu.IsIdentifier( '_f12' ) )
  ok_( iu.IsIdentifier( '_f12' ) )

  ok_( iu.IsIdentifier( 'uniçode' ) )
  ok_( iu.IsIdentifier( 'uç' ) )
  ok_( iu.IsIdentifier( 'ç' ) )
  ok_( iu.IsIdentifier( 'çode' ) )

  ok_( not iu.IsIdentifier( '1foo129' ) )
  ok_( not iu.IsIdentifier( '-foo' ) )
  ok_( not iu.IsIdentifier( 'foo-' ) )
  ok_( not iu.IsIdentifier( 'font-face' ) )
  ok_( not iu.IsIdentifier( None ) )
  ok_( not iu.IsIdentifier( '' ) )
def IsIdentifier_Tex_test():
  assert_that( iu.IsIdentifier( 'foo'        , 'tex' ) )
  assert_that( iu.IsIdentifier( 'fig:foo'    , 'tex' ) )
  assert_that( iu.IsIdentifier( 'fig:foo-bar', 'tex' ) )
  assert_that( iu.IsIdentifier( 'sec:summary', 'tex' ) )
  assert_that( iu.IsIdentifier( 'eq:bar_foo' , 'tex' ) )
  assert_that( iu.IsIdentifier( 'fōo'        , 'tex' ) )
  assert_that( iu.IsIdentifier( 'some8'      , 'tex' ) )

  assert_that( not iu.IsIdentifier( '\\section', 'tex' ) )
  assert_that( not iu.IsIdentifier( 'foo:'    , 'tex' ) )
  assert_that( not iu.IsIdentifier( '-bar'    , 'tex' ) )
  assert_that( not iu.IsIdentifier( ''        , 'tex' ) )