Package: src:lua-mode
Version: 20210802-3
Severity: serious
Tags: ftbfs
Dear maintainer:
During a rebuild of all packages in unstable, your package failed to build:
--------------------------------------------------------------------------------
[...]
debian/rules build
dh build --with elpa
dh_update_autotools_config
dh_autoreconf
dh_auto_configure
dh_auto_build
make -j2
make[1]: Entering directory '/<<PKGBUILDDIR>>'
Loading /etc/emacs/site-start.d/00debian.el (source)...
Loading /etc/emacs/site-start.d/50autoconf.el (source)...
Loading /etc/emacs/site-start.d/00debian.el (source)...
Loading /etc/emacs/site-start.d/50autoconf.el (source)...
Loading /etc/emacs/site-start.d/00debian.el (source)...
Loading /etc/emacs/site-start.d/50autoconf.el (source)...
Loading /etc/emacs/site-start.d/00debian.el (source)...
Loading /etc/emacs/site-start.d/50autoconf.el (source)...
version is 20210802
make[1]: Leaving directory '/<<PKGBUILDDIR>>'
dh_elpa_test
buttercup -L .
Loading /etc/emacs/site-start.d/00debian.el (source)...
Loading /etc/emacs/site-start.d/50autoconf.el (source)...
Warning (buttercup): Found duplicate spec names in suite: ("lua-skip-ws-and-comments-forward respects
limit when escaping multi-line comment 1: limit=8 \"--[[<1> <2> ]] \\n\"")
Running 392 out of 410 specs.
Test electric mode
works with curly braces
[32m works with curly braces[0m (3.66ms)
works with parentheses
[32m works with parentheses[0m (0.97ms)
works with end
[32m works with end[0m (1.13ms)
works with else
[32m works with else[0m (1.13ms)
works with elseif
[32m works with elseif[0m (1.16ms)
Electric pair mode
skips parens when electric-pair-skip-self is t
[32m skips parens when electric-pair-skip-self is t[0m (1.60ms)
Test fill-paragraph
fills single-line comment
[32m fills single-line comment[0m (0.45ms)
fills comment after code
[32m fills comment after code[0m (0.39ms)
fills multiline comment
[33m fills multiline comment[0m[33m PENDING[0m (0.07ms)
does not spill comments into code (issue #25)
[32m does not spill comments into code (issue #25)[0m (0.38ms)
Test fill-paragraph preserves point position
doesn't move point if nothing has changed
[32m doesn't move point if nothing has changed[0m (0.96ms)
doesn't move point in refilled region
[32m doesn't move point in refilled region[0m (2.26ms)
doesn't move point if nothing has changed (multi-line)
[32m doesn't move point if nothing has changed (multi-line)[0m (0.71ms)
Fontification of built-ins
fontifies built-ins
[32m fontifies built-ins[0m (0.27ms)
fontifies built-ins with spaces between members
[32m fontifies built-ins with spaces between members[0m (0.26ms)
doesn't fontify things that look like built-ins
[32m doesn't fontify things that look like built-ins[0m (0.50ms)
fontifies built-in class if method is not built-in
[32m fontifies built-in class if method is not built-in[0m (0.24ms)
fontifies built-ins after concatenation operator
[32m fontifies built-ins after concatenation operator[0m (0.19ms)
Fontification of constants
fontifies constants
[32m fontifies constants[0m (0.20ms)
fontifies constants used as attributes
[32m fontifies constants used as attributes[0m (0.19ms)
Fontification of keywords
fontifies keywords
[32m fontifies keywords[0m (0.27ms)
fontifies keywords used as attributes
[32m fontifies keywords used as attributes[0m (0.24ms)
Fontification of variables
fontifies "local foo, bar, baz = 1, 2, 3"
[32m fontifies "local foo, bar, baz = 1, 2, 3"[0m (0.21ms)
fontifies "local foo, bar, baz"
[32m fontifies "local foo, bar, baz"[0m (0.20ms)
fontifies "local x =" at end of buffer
[32m fontifies "local x =" at end of buffer[0m (0.16ms)
fontifies local "x =" at end of line
[32m fontifies local "x =" at end of line[0m (0.18ms)
does not fontify "for" inside strings
[32m does not fontify "for" inside strings[0m (0.22ms)
fontifies "for x123 ="
[32m fontifies "for x123 ="[0m (0.16ms)
fontifies "for x, y, z"
[32m fontifies "for x, y, z"[0m (0.18ms)
Fontification of function headers
fontifies function <name>(...) headers
[32m fontifies function <name>(...) headers[0m (0.20ms)
fontifies local function <name>(...) headers
[32m fontifies local function <name>(...) headers[0m (0.21ms)
fontifies <name> = function (...) headers
[32m fontifies <name> = function (...) headers[0m (0.19ms)
fontifies local <name> = function (...) headers
[32m fontifies local <name> = function (...) headers[0m (0.20ms)
fontifies parameters in function literals
[32m fontifies parameters in function literals[0m (0.18ms)
fontifies different variations of headers altogether
[32m fontifies different variations of headers altogether[0m (0.41ms)
fontifies headers inside tables
[32m fontifies headers inside tables[0m (0.31ms)
does not fail on issue #59 again
[32m does not fail on issue #59 again[0m (0.30ms)
does not choke on function names with underscores
[32m does not choke on function names with underscores[0m (0.40ms)
Fontification of goto labels
fontifies simple goto labels
[32m fontifies simple goto labels[0m (0.19ms)
fontifies ::labels:: written after code
[32m fontifies ::labels:: written after code[0m (0.22ms)
fontifies labels with spaces before and after "::"
[32m fontifies labels with spaces before and after "::"[0m (0.15ms)
does not fontify after symbols ending with "goto"
[32m does not fontify after symbols ending with "goto"[0m (0.15ms)
Fontification of LuaDoc keywords
works
[32m works[0m (0.57ms)
Test `lua-funcname-at-point'.
handles trailing periods
[32m handles trailing periods[0m (0.13ms)
handles point being in the middle
[32m handles point being in the middle[0m (0.11ms)
handles point being at the start of the buffer
[32m handles point being at the start of the buffer[0m (0.11ms)
handles identifiers before point
[32m handles identifiers before point[0m (0.12ms)
lua-forward-sexp
properly scans through curly braces
[32m properly scans through curly braces[0m (0.35ms)
scans through then .. end block
[32m scans through then .. end block[0m (0.31ms)
Check that beginning-of-defun works with
handles differed function headers
[32m handles differed function headers[0m (0.61ms)
accepts dots and colons
[32m accepts dots and colons[0m (0.33ms)
lua-mode
is derived from prog-mode
[32m is derived from prog-mode[0m (0.19ms)
imenu integration
indexes functions
[32m indexes functions[0m (0.37ms)
indexes require statements
[32m indexes require statements[0m (0.31ms)
lua-backward-up-list
doesn't move point when no parent block open token exists
[32m doesn't move point when no parent block open token exists[0m (0.22ms)
doesn't move point when cannot skip intermediate close token
[32m doesn't move point when cannot skip intermediate close token[0m (0.23ms)
works for (
[32m works for ([0m (0.22ms)
works for {
[32m works for {[0m (0.22ms)
works for else
[32m works for else[0m (0.22ms)
works for if/else/end
[32m works for if/else/end[0m (0.24ms)
works for do blocks
[32m works for do blocks[0m (0.24ms)
works for while/do
[32m works for while/do[0m (0.23ms)
skips complete while/do block
[32m skips complete while/do block[0m (0.34ms)
skips complete repeat/until block
[32m skips complete repeat/until block[0m (0.27ms)
skips complete if/elseif/else/end block
[32m skips complete if/elseif/else/end block[0m (0.36ms)
skips from else to previous then
[32m skips from else to previous then[0m (0.24ms)
skips from end to previous else
[32m skips from end to previous else[0m (0.25ms)
lua-goto-matching-block
works for do...end block
[32m works for do...end block[0m (1.07ms)
works for repeat...until block
[32m works for repeat...until block[0m (0.48ms)
works for while...do...end block
[32m works for while...do...end block[0m (1.09ms)
works for if..elseif..else..end block
[32m works for if..elseif..else..end block[0m (1.24ms)
Indentation test `issue-33.lua'
don't accumulate indentation after the expression
[31m don't accumulate indentation after the expression[0m[31m FAILED[0m
(0.10ms)
here foobar should be indented as simple continuation statement
[31m here foobar should be indented as simple continuation statement[0m[31m
FAILED[0m (0.08ms)
Indentation test `function-call-arguments.lua'
it works for single line case
[31m it works for single line case[0m[31m FAILED[0m (0.10ms)
it works for indenting all args on one line: close paren on separate line
[31m it works for indenting all args on one line: close paren on separate
line[0m[31m FAILED[0m (0.07ms)
it works for indenting all args in a column: close paren on separate line
[31m it works for indenting all args in a column: close paren on separate
line[0m[31m FAILED[0m (0.07ms)
it works for mixed arg indentation: close paren on separate line
[31m it works for mixed arg indentation: close paren on separate
line[0m[31m FAILED[0m (0.08ms)
it works with table ctorfor single line case
[31m it works with table ctorfor single line case[0m[31m FAILED[0m
(0.10ms)
it works with table ctor for indenting all args on one line: close paren on
separate line
[31m it works with table ctor for indenting all args on one line: close paren
on separate line[0m[31m FAILED[0m (0.07ms)
it works with table ctor for indenting all args in a column: close paren on
separate line
[31m it works with table ctor for indenting all args in a column: close paren
on separate line[0m[31m FAILED[0m (0.08ms)
it works with table ctor for mixed arg indentation: close paren on separate
line
[31m it works with table ctor for mixed arg indentation: close paren on
separate line[0m[31m FAILED[0m (0.09ms)
it works for mixed arg indentation with table in the middle: close paren on
separate line
[31m it works for mixed arg indentation with table in the middle: close paren
on separate line[0m[31m FAILED[0m (0.08ms)
it works for mixed arg indentation with table first: close paren on separate
line
[31m it works for mixed arg indentation with table first: close paren on
separate line[0m[31m FAILED[0m (0.10ms)
it works for mixed arg indentation with table last: close paren on separate
line
[31m it works for mixed arg indentation with table last: close paren on
separate line[0m[31m FAILED[0m (0.07ms)
Indentation test `only-use-last-opener.lua'
XFAIL: one param, nested table on same line as opener
[33m XFAIL: one param, nested table on same line as opener[0m[33m
PENDING[0m (0.08ms)
XFAIL: two params, nested table on same line as opener
[33m XFAIL: two params, nested table on same line as opener[0m[33m
PENDING[0m (0.08ms)
XFAIL: two aligned params, nested table on next line
[33m XFAIL: two aligned params, nested table on next line[0m[33m
PENDING[0m (0.06ms)
XFAIL: two aligned table params, first has nested tables
[33m XFAIL: two aligned table params, first has nested tables[0m[33m
PENDING[0m (0.09ms)
XFAIL: one nested table containing another table
[33m XFAIL: one nested table containing another table[0m[33m PENDING[0m
(0.08ms)
XFAIL: nested table with indentation: nested table on separate line
[33m XFAIL: nested table with indentation: nested table on separate
line[0m[33m PENDING[0m (0.06ms)
XFAIL: nested table with alignment: nested table on separate line
[33m XFAIL: nested table with alignment: nested table on separate
line[0m[33m PENDING[0m (0.07ms)
nested table with indentation: params after nested table
[31m nested table with indentation: params after nested table[0m[31m
FAILED[0m (0.09ms)
Indentation test `if-elseif-else-block.lua'
works for if/then block: 1
[31m works for if/then block: 1[0m[31m FAILED[0m (0.10ms)
works for if/then block: 2
[31m works for if/then block: 2[0m[31m FAILED[0m (0.06ms)
works for if/then block: 3
[31m works for if/then block: 3[0m[31m FAILED[0m (0.10ms)
works for if/then block: 4
[31m works for if/then block: 4[0m[31m FAILED[0m (0.07ms)
works for if/then block: 5
[31m works for if/then block: 5[0m[31m FAILED[0m (0.08ms)
works for if/then block: 6
[31m works for if/then block: 6[0m[31m FAILED[0m (0.07ms)
works for if/then block: single line 1
[31m works for if/then block: single line 1[0m[31m FAILED[0m (0.07ms)
works for if/then block: single line 2
[31m works for if/then block: single line 2[0m[31m FAILED[0m (0.08ms)
works for if/then block: single line 3
[31m works for if/then block: single line 3[0m[31m FAILED[0m (0.07ms)
works for if/then block: single line 4
[31m works for if/then block: single line 4[0m[31m FAILED[0m (0.08ms)
works for if/else block: 1
[31m works for if/else block: 1[0m[31m FAILED[0m (0.07ms)
works for if/else block: 2
[31m works for if/else block: 2[0m[31m FAILED[0m (0.09ms)
works for if/else block: 3
[31m works for if/else block: 3[0m[31m FAILED[0m (0.07ms)
works for if/else block: 4
[31m works for if/else block: 4[0m[31m FAILED[0m (0.07ms)
works for if/else block: 5
[31m works for if/else block: 5[0m[31m FAILED[0m (0.07ms)
works for if/else block: single line 1
[31m works for if/else block: single line 1[0m[31m FAILED[0m (0.07ms)
works for if/else block: single line 2
[31m works for if/else block: single line 2[0m[31m FAILED[0m (0.07ms)
works for if/else block: single line 3
[31m works for if/else block: single line 3[0m[31m FAILED[0m (0.08ms)
works for if/else block: single line 4
[31m works for if/else block: single line 4[0m[31m FAILED[0m (0.07ms)
XFAIL: works for if/else block: single line 5
[33m XFAIL: works for if/else block: single line 5[0m[33m PENDING[0m
(0.07ms)
works for if/else block: single line 6
[31m works for if/else block: single line 6[0m[31m FAILED[0m (0.07ms)
XFAIL: works for if/else block: parentheses in conditional
[33m XFAIL: works for if/else block: parentheses in conditional[0m[33m
PENDING[0m (0.09ms)
works for if/elseif/else block: 1
[31m works for if/elseif/else block: 1[0m[31m FAILED[0m (0.07ms)
works for if/elseif/else block: 2
[31m works for if/elseif/else block: 2[0m[31m FAILED[0m (0.07ms)
XFAIL: works for if/elseif/else block: 3
[33m XFAIL: works for if/elseif/else block: 3[0m[33m PENDING[0m (0.07ms)
XFAIL: works for if/elseif/else block: 4
[33m XFAIL: works for if/elseif/else block: 4[0m[33m PENDING[0m (0.07ms)
Indentation test `for-equals-block.lua'
works for "for ... = ... do" block: 1
[31m works for "for ... = ... do" block: 1[0m[31m FAILED[0m (0.08ms)
works for "for ... = ... do" block: 2
[31m works for "for ... = ... do" block: 2[0m[31m FAILED[0m (0.07ms)
works for "for ... = ... do" block: 3
[31m works for "for ... = ... do" block: 3[0m[31m FAILED[0m (0.07ms)
works for "for ... = ... do" block: 4
[31m works for "for ... = ... do" block: 4[0m[31m FAILED[0m (0.07ms)
works for "for ... = ... do" block: 5
[31m works for "for ... = ... do" block: 5[0m[31m FAILED[0m (0.08ms)
works for "for ... = ... do" block: 6
[31m works for "for ... = ... do" block: 6[0m[31m FAILED[0m (0.07ms)
works for "for ... = ... do" block: 7
[31m works for "for ... = ... do" block: 7[0m[31m FAILED[0m (0.08ms)
works for "for ... = ... do" block: single line
[31m works for "for ... = ... do" block: single line[0m[31m FAILED[0m
(0.07ms)
Indentation test `smoke.lua'
section 1
[31m section 1[0m[31m FAILED[0m (0.10ms)
Indentation test `goto-label.lua'
is sane
[31m is sane[0m[31m FAILED[0m (0.08ms)
does not affect indentation when put on a separate line
[31m does not affect indentation when put on a separate line[0m[31m
FAILED[0m (0.08ms)
XFAIL: does not affect indentation before block modifiers
[33m XFAIL: does not affect indentation before block modifiers[0m[33m
PENDING[0m (0.07ms)
does not affect indentation after block modifiers
[31m does not affect indentation after block modifiers[0m[31m FAILED[0m
(0.06ms)
reindents according to luawiki examples: 1
[31m reindents according to luawiki examples: 1[0m[31m FAILED[0m (0.08ms)
reindents according to luawiki examples: 2
[31m reindents according to luawiki examples: 2[0m[31m FAILED[0m (0.07ms)
reindents according to luawiki examples: 3
[31m reindents according to luawiki examples: 3[0m[31m FAILED[0m (0.08ms)
reindents according to luawiki examples: 4
[31m reindents according to luawiki examples: 4[0m[31m FAILED[0m (0.07ms)
reindents according to luawiki examples: 5
[31m reindents according to luawiki examples: 5[0m[31m FAILED[0m (0.08ms)
reindents according to luawiki examples: 6
[31m reindents according to luawiki examples: 6[0m[31m FAILED[0m (0.07ms)
reindents according to luawiki examples: 7
[31m reindents according to luawiki examples: 7[0m[31m FAILED[0m (0.09ms)
Indentation test `for-in-block.lua'
works for "for .. in .. do" block: 1
[31m works for "for .. in .. do" block: 1[0m[31m FAILED[0m (0.10ms)
works for "for .. in .. do" block: 2
[31m works for "for .. in .. do" block: 2[0m[31m FAILED[0m (0.06ms)
works for "for .. in .. do" block: 3
[31m works for "for .. in .. do" block: 3[0m[31m FAILED[0m (0.07ms)
works for "for .. in .. do" block: 4
[31m works for "for .. in .. do" block: 4[0m[31m FAILED[0m (0.08ms)
works for "for .. in .. do" block: 5
[31m works for "for .. in .. do" block: 5[0m[31m FAILED[0m (0.07ms)
works for "for .. in .. do" block: 6
[31m works for "for .. in .. do" block: 6[0m[31m FAILED[0m (0.08ms)
works for "for .. in .. do" block: 7
[31m works for "for .. in .. do" block: 7[0m[31m FAILED[0m (0.07ms)
works for "for .. in .. do" block: 8
[31m works for "for .. in .. do" block: 8[0m[31m FAILED[0m (0.08ms)
works for "for .. in .. do" block: 9
[31m works for "for .. in .. do" block: 9[0m[31m FAILED[0m (0.07ms)
works for "for .. in .. do" block: single line
[31m works for "for .. in .. do" block: single line[0m[31m FAILED[0m
(0.08ms)
Indentation test `repeat-until-block.lua'
works for repeat ... until blocks: 1
[31m works for repeat ... until blocks: 1[0m[31m FAILED[0m (0.10ms)
works for repeat ... until blocks: 2
[31m works for repeat ... until blocks: 2[0m[31m FAILED[0m (0.07ms)
works for repeat ... until blocks: 3
[31m works for repeat ... until blocks: 3[0m[31m FAILED[0m (0.08ms)
works for repeat ... until blocks: 4
[31m works for repeat ... until blocks: 4[0m[31m FAILED[0m (0.07ms)
works for repeat ... until blocks: single line
[31m works for repeat ... until blocks: single line[0m[31m FAILED[0m
(0.08ms)
works for repeat ... until blocks: single line with continuation 1
[31m works for repeat ... until blocks: single line with continuation
1[0m[31m FAILED[0m (0.08ms)
XFAIL: works for repeat ... until blocks: single line with continuation 1
[33m XFAIL: works for repeat ... until blocks: single line with continuation
1[0m[33m PENDING[0m (0.07ms)
Indentation test `do-block.lua'
works for do ... end blocks on separate lines
[31m works for do ... end blocks on separate lines[0m[31m FAILED[0m
(0.07ms)
works for do ... end blocks: single line
[31m works for do ... end blocks: single line[0m[31m FAILED[0m (0.08ms)
works for do ... end blocks: body on the same line
[31m works for do ... end blocks: body on the same line[0m[31m FAILED[0m
(0.07ms)
works for do ... end blocks: continuation inside body
[31m works for do ... end blocks: continuation inside body[0m[31m
FAILED[0m (0.06ms)
works for do ... end blocks: parentheses inside body
[31m works for do ... end blocks: parentheses inside body[0m[31m
FAILED[0m (0.06ms)
Indentation test `while-block.lua'
works for while ... do ... end blocks: 1
[31m works for while ... do ... end blocks: 1[0m[31m FAILED[0m (0.05ms)
works for while ... do ... end blocks: 2
[31m works for while ... do ... end blocks: 2[0m[31m FAILED[0m (0.06ms)
works for while ... do ... end blocks: 3
[31m works for while ... do ... end blocks: 3[0m[31m FAILED[0m (0.05ms)
works for while ... do ... end blocks: 4
[31m works for while ... do ... end blocks: 4[0m[31m FAILED[0m (0.07ms)
works for while ... do ... end blocks: 5
[31m works for while ... do ... end blocks: 5[0m[31m FAILED[0m (0.05ms)
works for while ... do ... end blocks: 6
[31m works for while ... do ... end blocks: 6[0m[31m FAILED[0m (0.06ms)
works for while ... do ... end blocks: 7
[31m works for while ... do ... end blocks: 7[0m[31m FAILED[0m (0.05ms)
works for while ... do ... end blocks: 8
[31m works for while ... do ... end blocks: 8[0m[31m FAILED[0m (0.06ms)
works for while ... do ... end blocks: single line
[31m works for while ... do ... end blocks: single line[0m[31m FAILED[0m
(0.06ms)
works for while ... do ... end blocks: single line with continuation in body
[31m works for while ... do ... end blocks: single line with continuation in
body[0m[31m FAILED[0m (0.08ms)
works for while ... do ... end blocks: single line with parentheses in body
[31m works for while ... do ... end blocks: single line with parentheses in
body[0m[31m FAILED[0m (0.06ms)
Indentation test `assignment-indentation.lua'
ensure is sane
[31m ensure is sane[0m[31m FAILED[0m (0.06ms)
add continuation before =
[31m add continuation before =[0m[31m FAILED[0m (0.05ms)
add continuation after =
[31m add continuation after =[0m[31m FAILED[0m (0.06ms)
continuation after comma: 1
[31m continuation after comma: 1[0m[31m FAILED[0m (0.06ms)
continuation after comma: 2
[31m continuation after comma: 2[0m[31m FAILED[0m (0.06ms)
continuation after comma: 3
[31m continuation after comma: 3[0m[31m FAILED[0m (0.05ms)
continuation after comma: 4
[31m continuation after comma: 4[0m[31m FAILED[0m (0.06ms)
continuation after comma: 5
[31m continuation after comma: 5[0m[31m FAILED[0m (0.08ms)
continuation after "local": 1
[31m continuation after "local": 1[0m[31m FAILED[0m (0.05ms)
continuation after "local": 2
[31m continuation after "local": 2[0m[31m FAILED[0m (0.06ms)
continuation after "local": 3
[31m continuation after "local": 3[0m[31m FAILED[0m (0.05ms)
continuation after "local": 4
[31m continuation after "local": 4[0m[31m FAILED[0m (0.06ms)
indentation of function call arguments in continuation part
[31m indentation of function call arguments in continuation part[0m[31m
FAILED[0m (0.06ms)
does not indent binary operators inside parentheses: alignment 1
[31m does not indent binary operators inside parentheses: alignment
1[0m[31m FAILED[0m (0.06ms)
does not indent binary operators inside parentheses: alignment 2
[31m does not indent binary operators inside parentheses: alignment
2[0m[31m FAILED[0m (0.06ms)
does not indent binary operators inside parentheses: indentation 1
[31m does not indent binary operators inside parentheses: indentation
1[0m[31m FAILED[0m (0.06ms)
does not indent binary operators inside parentheses: indentation 2
[31m does not indent binary operators inside parentheses: indentation
2[0m[31m FAILED[0m (0.06ms)
it unindents close paren for arithmetical expression
[31m it unindents close paren for arithmetical expression[0m[31m
FAILED[0m (0.06ms)
it unindents close paren for arithmetical expression: local
[31m it unindents close paren for arithmetical expression: local[0m[31m
FAILED[0m (0.06ms)
it unindents close paren for function call
[31m it unindents close paren for function call[0m[31m FAILED[0m (0.06ms)
it unindents close paren for function call: local
[31m it unindents close paren for function call: local[0m[31m FAILED[0m
(0.06ms)
it unindents close brace for table ctor
[31m it unindents close brace for table ctor[0m[31m FAILED[0m (0.06ms)
it unindents close brace for table ctor: local
[31m it unindents close brace for table ctor: local[0m[31m FAILED[0m
(0.06ms)
XFAIL: it unindents close bracket for indexing
[33m XFAIL: it unindents close bracket for indexing[0m[33m PENDING[0m
(0.03ms)
XFAIL: it unindents close bracket for indexing: local
[33m XFAIL: it unindents close bracket for indexing: local[0m[33m
PENDING[0m (0.04ms)
does not indent binary operators inside brackets: alignment 1
[31m does not indent binary operators inside brackets: alignment 1[0m[31m
FAILED[0m (0.06ms)
does not indent binary operators inside brackets: alignment 2
[31m does not indent binary operators inside brackets: alignment 2[0m[31m
FAILED[0m (0.06ms)
does not indent binary operators inside brackets: indentation 1
[31m does not indent binary operators inside brackets: indentation 1[0m[31m
FAILED[0m (0.06ms)
does not indent binary operators inside brackets: indentation 2
[31m does not indent binary operators inside brackets: indentation 2[0m[31m
FAILED[0m (0.06ms)
Indentation test `continuation-lines.lua'
indentation if broken in the middle of \"foo.bar\" and \"qux:quux\"
[31m indentation if broken in the middle of \"foo.bar\" and
\"qux:quux\"[0m[31m FAILED[0m (0.06ms)
indentation after return
[31m indentation after return[0m[31m FAILED[0m (0.05ms)
indentation after return: blocks
[31m indentation after return: blocks[0m[31m FAILED[0m (0.06ms)
indentation after return: f1
[31m indentation after return: f1[0m[31m FAILED[0m (0.05ms)
indentation after return: f2
[31m indentation after return: f2[0m[31m FAILED[0m (0.07ms)
indentation after return: f3
[31m indentation after return: f3[0m[31m FAILED[0m (0.05ms)
indentation after ellipsis
[31m indentation after ellipsis[0m[31m FAILED[0m (0.06ms)
indentation in block-intros: while
[31m indentation in block-intros: while[0m[31m FAILED[0m (0.06ms)
indentation in block-intros: while 2
[31m indentation in block-intros: while 2[0m[31m FAILED[0m (0.06ms)
indents expressions after return: basic
[31m indents expressions after return: basic[0m[31m FAILED[0m (0.05ms)
indents expressions after return: function literal
[31m indents expressions after return: function literal[0m[31m FAILED[0m
(0.06ms)
indents expressions after return: ellipsis
[31m indents expressions after return: ellipsis[0m[31m FAILED[0m (0.05ms)
does not indents keywords after return: end
[31m does not indents keywords after return: end[0m[31m FAILED[0m (0.06ms)
does not indents keywords after return: if/end
[31m does not indents keywords after return: if/end[0m[31m FAILED[0m
(0.06ms)
does not indents keywords after return: if/else
[31m does not indents keywords after return: if/else[0m[31m FAILED[0m
(0.06ms)
does not indents keywords after return: if/elseif
[31m does not indents keywords after return: if/elseif[0m[31m FAILED[0m
(0.06ms)
does not indents keywords after return: repeat/until
[31m does not indents keywords after return: repeat/until[0m[31m
FAILED[0m (0.06ms)
does not indents keywords after return: semicolon 1
[31m does not indents keywords after return: semicolon 1[0m[31m FAILED[0m
(0.06ms)
does not indents keywords after return: semicolon 2
[31m does not indents keywords after return: semicolon 2[0m[31m FAILED[0m
(0.06ms)
Continuation lines
are indented before/after binary operators: +
[32m are indented before/after binary operators: +[0m (0.76ms)
are indented before/after binary operators: -
[32m are indented before/after binary operators: -[0m (0.68ms)
are indented before/after binary operators: *
[32m are indented before/after binary operators: *[0m (0.65ms)
are indented before/after binary operators: /
[32m are indented before/after binary operators: /[0m (0.64ms)
are indented before/after binary operators: ^
[32m are indented before/after binary operators: ^[0m (0.63ms)
are indented before/after binary operators: %
[32m are indented before/after binary operators: %[0m (0.64ms)
are indented before/after binary operators: ..
[32m are indented before/after binary operators: ..[0m (0.64ms)
are indented before/after binary operators: <
[32m are indented before/after binary operators: <[0m (0.67ms)
are indented before/after binary operators: <=
[32m are indented before/after binary operators: <=[0m (0.64ms)
are indented before/after binary operators: >
[32m are indented before/after binary operators: >[0m (0.64ms)
are indented before/after binary operators: >=
[32m are indented before/after binary operators: >=[0m (0.63ms)
are indented before/after binary operators: ==
[32m are indented before/after binary operators: ==[0m (0.63ms)
are indented before/after binary operators: ~=
[32m are indented before/after binary operators: ~=[0m (0.65ms)
are indented before/after binary operators: and
[32m are indented before/after binary operators: and[0m (0.67ms)
are indented before/after binary operators: or
[32m are indented before/after binary operators: or[0m (0.63ms)
Function indentation
indents function call arguments
[32m indents function call arguments[0m (1.96ms)
indent blocks with lua-indent-nested-block-content-align
[32m indent blocks with lua-indent-nested-block-content-align[0m (1.82ms)
indent blocks with lua-indent-close-paren-align
[32m indent blocks with lua-indent-close-paren-align[0m (0.88ms)
indents nested tables with alternative block indenting
[32m indents nested tables with alternative block indenting[0m (4.87ms)
Hiding process buffer does not switch current window
when process is active
[32m when process is active[0m (3.70ms)
and does not signal when process is already killed
[32m and does not signal when process is already killed[0m (1.80ms)
when process is not started
[32m when process is not started[0m (0.26ms)
Compilation minor mode
sets comint-prompt-regexp in process buffer
[32m sets comint-prompt-regexp in process buffer[0m (2.00ms)
Fontification in compilation buffer
fontifies runtime error messages
[33m fontifies runtime error messages[0m[33m PENDING[0m (0.07ms)
fontifies syntax error messages
[33m fontifies syntax error messages[0m[33m PENDING[0m (0.05ms)
String escaping
Escapes literal tabs
[32m Escapes literal tabs[0m (0.14ms)
`lua-start-process'
doesn't hang for an already-running process
[32m doesn't hang for an already-running process[0m (1.67ms)
Test indent-new-comment-line
works with -- ...
[32m works with -- ...[0m (1.57ms)
works with ---- ....
[32m works with ---- ....[0m (0.91ms)
doesn't recognize "--" inside strings and comments
[32m doesn't recognize "--" inside strings and comments[0m (2.11ms)
works when the comment is empty
[32m works when the comment is empty[0m (0.71ms)
lua-comment-start-pos
returns beginning of single-line comment if inside
[32m returns beginning of single-line comment if inside[0m (0.29ms)
returns beginning of single-line comment if between delimiters
[32m returns beginning of single-line comment if between delimiters[0m
(0.27ms)
returns nil if before delimiters
[32m returns nil if before delimiters[0m (0.31ms)
returns nil if before single-line comment
[32m returns nil if before single-line comment[0m (0.27ms)
returns nil if after single-line comment
[32m returns nil if after single-line comment[0m (0.27ms)
returns nil if inside single-line string
[32m returns nil if inside single-line string[0m (0.29ms)
returns nil if inside multi-line string
[32m returns nil if inside multi-line string[0m (0.29ms)
returns beginning of multi-line comment if inside 1
[32m returns beginning of multi-line comment if inside 1[0m (0.28ms)
returns beginning of multi-line comment if inside 2
[32m returns beginning of multi-line comment if inside 2[0m (0.28ms)
returns beginning of multi-line comment if inside 3
[32m returns beginning of multi-line comment if inside 3[0m (0.29ms)
returns beginning of multi-line comment if between delimiters 1
[32m returns beginning of multi-line comment if between delimiters 1[0m
(0.28ms)
returns beginning of single-line comment if between delimiters 2
[32m returns beginning of single-line comment if between delimiters 2[0m
(0.28ms)
returns beginning of multi-line comment if between delimiters 3
[32m returns beginning of multi-line comment if between delimiters 3[0m
(0.27ms)
returns beginning of multi-line comment if between delimiters 4
[32m returns beginning of multi-line comment if between delimiters 4[0m
(0.29ms)
returns beginning of multi-line comment if between delimiters 5
[32m returns beginning of multi-line comment if between delimiters 5[0m
(0.28ms)
returns nil if before multi-line opener
[32m returns nil if before multi-line opener[0m (0.29ms)
returns nil if after multi-line closer
[32m returns nil if after multi-line closer[0m (0.27ms)
returns beginning of multi-line comment if after multi-line closer with
different opener
[32m returns beginning of multi-line comment if after multi-line closer with
different opener[0m (0.28ms)
returns nil if multi-line opener is inside string 1
[32m returns nil if multi-line opener is inside string 1[0m (0.34ms)
returns nil if multi-line opener is inside string 2
[32m returns nil if multi-line opener is inside string 2[0m (0.28ms)
returns nil if multi-line opener is inside multi-line string 1
[32m returns nil if multi-line opener is inside multi-line string 1[0m
(0.28ms)
returns nil if multi-line opener is inside multi-line string 2
[32m returns nil if multi-line opener is inside multi-line string 2[0m
(0.29ms)
lua-comment-or-string-start-p/-pos
returns nil for ("<>'foo'")
[32m returns nil for ("<>'foo'")[0m (0.33ms)
returns truthy/1 for ("'<>foo'")
[32m returns truthy/1 for ("'<>foo'")[0m (14.37ms)
returns truthy/1 for ("'foo<>'")
[32m returns truthy/1 for ("'foo<>'")[0m (0.47ms)
returns nil for ("'foo'<>")
[32m returns nil for ("'foo'<>")[0m (0.45ms)
returns nil for ("<>\"foo\"")
[32m returns nil for ("<>\"foo\"")[0m (0.43ms)
returns truthy/1 for ("\"<>foo\"")
[32m returns truthy/1 for ("\"<>foo\"")[0m (0.43ms)
returns truthy/1 for ("\"foo<>\"")
[32m returns truthy/1 for ("\"foo<>\"")[0m (0.29ms)
returns nil for ("\"foo\"<>")
[32m returns nil for ("\"foo\"<>")[0m (0.28ms)
returns nil for ("<>[[foo]]")
[32m returns nil for ("<>[[foo]]")[0m (0.28ms)
returns truthy/1 for ("[[<>foo]]")
[32m returns truthy/1 for ("[[<>foo]]")[0m (0.28ms)
returns truthy/1 for ("[<>[foo]]")
[32m returns truthy/1 for ("[<>[foo]]")[0m (0.28ms)
returns truthy/1 for ("[=<>[foo]=]")
[32m returns truthy/1 for ("[=<>[foo]=]")[0m (0.28ms)
returns truthy/1 for ("[<>=[foo]=]")
[32m returns truthy/1 for ("[<>=[foo]=]")[0m (0.32ms)
returns truthy/1 for ("[[foo<>]]")
[32m returns truthy/1 for ("[[foo<>]]")[0m (0.28ms)
returns truthy/1 for ("[[foo]<>]")
[32m returns truthy/1 for ("[[foo]<>]")[0m (0.27ms)
returns truthy/1 for ("[[foo]<>=]")
[32m returns truthy/1 for ("[[foo]<>=]")[0m (0.28ms)
returns truthy/1 for ("[[foo]=<>]")
[32m returns truthy/1 for ("[[foo]=<>]")[0m (0.27ms)
returns nil for ("[[foo]]<>")
[32m returns nil for ("[[foo]]<>")[0m (0.29ms)
returns nil for ("foo <>-- bar")
[32m returns nil for ("foo <>-- bar")[0m (0.26ms)
returns truthy/5 for ("foo -<>- bar")
[32m returns truthy/5 for ("foo -<>- bar")[0m (0.26ms)
returns truthy/5 for ("foo --<> bar")
[32m returns truthy/5 for ("foo --<> bar")[0m (0.26ms)
returns truthy/5 for ("foo -- <>bar")
[32m returns truthy/5 for ("foo -- <>bar")[0m (0.26ms)
returns truthy/5 for ("foo -- bar<>")
[32m returns truthy/5 for ("foo -- bar<>")[0m (0.26ms)
returns nil for ("foo <>--[[ bar ]]")
[32m returns nil for ("foo <>--[[ bar ]]")[0m (0.29ms)
returns truthy/5 for ("foo -<>-[[ bar ]]")
[32m returns truthy/5 for ("foo -<>-[[ bar ]]")[0m (0.28ms)
returns truthy/5 for ("foo --<>[[ bar ]]")
[32m returns truthy/5 for ("foo --<>[[ bar ]]")[0m (0.30ms)
returns truthy/5 for ("foo --[<>[ bar ]]")
[32m returns truthy/5 for ("foo --[<>[ bar ]]")[0m (0.28ms)
returns truthy/5 for ("foo --[[<> bar ]]")
[32m returns truthy/5 for ("foo --[[<> bar ]]")[0m (0.28ms)
returns truthy/5 for ("foo --[[ bar <>]]")
[32m returns truthy/5 for ("foo --[[ bar <>]]")[0m (0.27ms)
returns truthy/5 for ("foo --[[ bar ]<>]")
[32m returns truthy/5 for ("foo --[[ bar ]<>]")[0m (0.28ms)
returns nil for ("foo --[[ bar ]]<>")
[32m returns nil for ("foo --[[ bar ]]<>")[0m (0.28ms)
returns truthy/5 for ("foo --[==[ bar ]]<>")
[32m returns truthy/5 for ("foo --[==[ bar ]]<>")[0m (0.27ms)
returns nil for ("foo <>---[[ bar ]]")
[32m returns nil for ("foo <>---[[ bar ]]")[0m (0.27ms)
returns truthy/5 for ("foo --<>-[[ bar ]]")
[32m returns truthy/5 for ("foo --<>-[[ bar ]]")[0m (0.27ms)
returns truthy/5 for ("foo ---<>[[ bar ]]")
[32m returns truthy/5 for ("foo ---<>[[ bar ]]")[0m (0.27ms)
returns truthy/5 for ("foo ---[<>[ bar ]]")
[32m returns truthy/5 for ("foo ---[<>[ bar ]]")[0m (0.27ms)
returns truthy/5 for ("foo ---[[<> bar ]]")
[32m returns truthy/5 for ("foo ---[[<> bar ]]")[0m (0.28ms)
returns truthy/5 for ("foo ---[[ bar ]]<>")
[32m returns truthy/5 for ("foo ---[[ bar ]]<>")[0m (0.28ms)
returns nil for ("foo --[[ -- bar ]]<>")
[32m returns nil for ("foo --[[ -- bar ]]<>")[0m (0.29ms)
returns nil for ("foo '--[[' <> bar ]]")
[32m returns nil for ("foo '--[[' <> bar ]]")[0m (0.50ms)
returns nil for ("foo [[--[[]] <> bar ]]")
[32m returns nil for ("foo [[--[[]] <> bar ]]")[0m (0.29ms)
returns nil for ("foo [[--[==[]] <> bar ]==]")
[32m returns nil for ("foo [[--[==[]] <> bar ]==]")[0m (0.31ms)
returns nil for ("foo = bar -<> baz")
[32m returns nil for ("foo = bar -<> baz")[0m (0.32ms)
returns nil for ("foo = bar <>- baz")
[32m returns nil for ("foo = bar <>- baz")[0m (0.30ms)
lua-skip-ws-and-comments-backward
doesn't move point
empty buffer: "<>"
[32m empty buffer: "<>"[0m (0.29ms)
at beginning of non-empty buffer: "<> --[[]]foo"
[32m at beginning of non-empty buffer: "<> --[[]]foo"[0m (0.34ms)
in the middle of variable: " f<>oo"
[32m in the middle of variable: " f<>oo"[0m (0.28ms)
at the end of variable: " foo<>"
[32m at the end of variable: " foo<>"[0m (0.24ms)
between variable and comment: " foo<>--"
[32m between variable and comment: " foo<>--"[0m (0.25ms)
at the end of single-quote string literal: " foo 'bar'<>"
[32m at the end of single-quote string literal: " foo 'bar'<>"[0m
(0.36ms)
at the end of multi-line string literal: " foo [[bar]]<>"
[32m at the end of multi-line string literal: " foo [[bar]]<>"[0m
(0.26ms)
inside string literal: " foo '<>bar'"
[32m inside string literal: " foo '<>bar'"[0m (0.34ms)
inside function call literal: " foo (<>bar)"
[32m inside function call literal: " foo (<>bar)"[0m (0.27ms)
within whitespace inside single-line string literal: " foo '-- <> bar'"
[32m within whitespace inside single-line string literal: " foo '-- <>
bar'"[0m (0.32ms)
within whitespace inside multi-line string literal: " foo [[-- \n<>
bar]]"
[32m within whitespace inside multi-line string literal: " foo [[-- \n<>
bar]]"[0m (0.31ms)
moves point
skip whitespace at the beginning of buffer: "<2> <1>"
[32m skip whitespace at the beginning of buffer: "<2> <1>"[0m (0.25ms)
skip ws after variable: "foo<2> <1>"
[32m skip ws after variable: "foo<2> <1>"[0m (0.25ms)
skip ws after function call: "foo()<2> <1>"
[32m skip ws after function call: "foo()<2> <1>"[0m (0.29ms)
skip newlines/tabs/spaces after variable: "foo<2> \n \n<1>"
[32m skip newlines/tabs/spaces after variable: "foo<2> \n \n<1>"[0m
(0.30ms)
escape single-line comment and skip ws: "foo<2> -- <1>"
[32m escape single-line comment and skip ws: "foo<2> -- <1>"[0m (0.26ms)
escape single-line comment delimiter: "foo<2> -<1>-"
[32m escape single-line comment delimiter: "foo<2> -<1>-"[0m (0.24ms)
escape commented out string and skip ws: "foo<2> -- '<1>'"
[32m escape commented out string and skip ws: "foo<2> -- '<1>'"[0m
(0.30ms)
escape commented out string and skip ws: "foo<2> -- [[<1>]]"
[32m escape commented out string and skip ws: "foo<2> -- [[<1>]]"[0m
(0.28ms)
skip single-line comment and ws: "foo<2> -- \n<1>"
[32m skip single-line comment and ws: "foo<2> -- \n<1>"[0m (0.25ms)
skip several single-line comments and ws: "foo<2> -- \n--\n--\n<1>"
[32m skip several single-line comments and ws: "foo<2> --
\n--\n--\n<1>"[0m (0.28ms)
escape multi-line comment and skip ws: "foo<2> --[[ <1> ]]"
[32m escape multi-line comment and skip ws: "foo<2> --[[ <1> ]]"[0m
(0.28ms)
escape multi-line comment delimiter and skip ws 1: "foo<2> -<1>-[[ ]]"
[32m escape multi-line comment delimiter and skip ws 1: "foo<2> -<1>-[[
]]"[0m (0.30ms)
escape multi-line comment delimiter and skip ws 2: "foo<2> --<1>[[ ]]"
[32m escape multi-line comment delimiter and skip ws 2: "foo<2> --<1>[[
]]"[0m (0.30ms)
escape multi-line comment delimiter and skip ws 3: "foo<2> --[<1>[ ]]"
[32m escape multi-line comment delimiter and skip ws 3: "foo<2> --[<1>[
]]"[0m (0.28ms)
escape multi-line comment delimiter and skip ws 4: "foo<2> --[[ ]<1>]"
[32m escape multi-line comment delimiter and skip ws 4: "foo<2> --[[
]<1>]"[0m (0.29ms)
skip multi-line comments and ws: "foo<2> --[[ \n\n ]]\n\n--[[ ]]<1>"
[32m skip multi-line comments and ws: "foo<2> --[[ \n\n ]]\n\n--[[
]]<1>"[0m (0.30ms)
escape multi-line comment with luadoc keyword 1: "foo<2> --[[ @see foo
<1>]]"
[32m escape multi-line comment with luadoc keyword 1: "foo<2> --[[ @see foo
<1>]]"[0m (0.32ms)
escape multi-line comment with luadoc keyword 2: "foo<2> --[[ @s<1>ee foo
]]"
[32m escape multi-line comment with luadoc keyword 2: "foo<2> --[[ @s<1>ee foo
]]"[0m (0.33ms)
escape multi-line comment with luadoc keyword 3: "foo<2> --[[ <1>@see foo
]]"
[32m escape multi-line comment with luadoc keyword 3: "foo<2> --[[ <1>@see foo
]]"[0m (0.28ms)
escape single-line comment with luadoc keyword 1: "foo<2> -- @see foo <1>"
[32m escape single-line comment with luadoc keyword 1: "foo<2> -- @see foo
<1>"[0m (0.27ms)
escape single-line comment with luadoc keyword 2: "foo<2> -- @s<1>ee foo "
[32m escape single-line comment with luadoc keyword 2: "foo<2> -- @s<1>ee foo
"[0m (0.28ms)
escape single-line comment with luadoc keyword 3: "foo<2> -- <1>@see foo "
[32m escape single-line comment with luadoc keyword 3: "foo<2> -- <1>@see foo
"[0m (0.25ms)
respects limit
respect limit in whitespace: limit=3 " <2> <1>"
[32m respect limit in whitespace: limit=3 " <2> <1>"[0m (0.32ms)
don't move if limit is beyond point: limit=100 " <2><1> "
[32m don't move if limit is beyond point: limit=100 " <2><1> "[0m
(0.31ms)
respect limit when escaping single-line comment: limit=5 "-- <2> <1>"
[32m respect limit when escaping single-line comment: limit=5 "-- <2>
<1>"[0m (0.26ms)
respect limit when escaping multi-line comment: limit=5 "--[[<2> <1>]]"
[32m respect limit when escaping multi-line comment: limit=5 "--[[<2>
<1>]]"[0m (0.26ms)
respect limit when escaping multi-line comment: limit=5 " <2>-- <1>"
[32m respect limit when escaping multi-line comment: limit=5 " <2>--
<1>"[0m (0.26ms)
respect limit when escaping multi-line comment: limit=5 " <2>--[[
<1>]]"
[32m respect limit when escaping multi-line comment: limit=5 " <2>--[[
<1>]]"[0m (0.30ms)
respect limit when escaping single-line luadoc comment: limit=5 "-- <2>@see x
<1>"
[32m respect limit when escaping single-line luadoc comment: limit=5 "-- <2>@see x
<1>"[0m (0.25ms)
respect limit when escaping multi-line luadoc comment: limit=5 "--[[<2>@see x
<1>]]"
[32m respect limit when escaping multi-line luadoc comment: limit=5 "--[[<2>@see x
<1>]]"[0m (0.27ms)
lua-skip-ws-and-comments-forward
doesn't move point
empty buffer: "<>"
[32m empty buffer: "<>"[0m (0.28ms)
at end of non-empty buffer: " --[[]]<>"
[32m at end of non-empty buffer: " --[[]]<>"[0m (0.30ms)
in the middle of variable: " f<>oo "
[32m in the middle of variable: " f<>oo "[0m (0.30ms)
at the beginning of variable: " <>foo "
[32m at the beginning of variable: " <>foo "[0m (0.27ms)
between variable and comment: " --[[]]<>foo "
[32m between variable and comment: " --[[]]<>foo "[0m (0.29ms)
at the end of single-quote string literal: " foo <>'bar'"
[32m at the end of single-quote string literal: " foo <>'bar'"[0m
(0.34ms)
at the end of multi-line string literal: " foo <>[[bar]]"
[32m at the end of multi-line string literal: " foo <>[[bar]]"[0m
(0.32ms)
inside string literal: " foo 'bar<>'"
[32m inside string literal: " foo 'bar<>'"[0m (0.25ms)
inside function call literal: " foo (bar<>)"
[32m inside function call literal: " foo (bar<>)"[0m (0.26ms)
within whitespace inside single-line string literal: " foo '-- <> bar'"
[32m within whitespace inside single-line string literal: " foo '-- <>
bar'"[0m (0.25ms)
within whitespace inside multi-line string literal: " foo [[-- \n<>\n
bar]]"
[32m within whitespace inside multi-line string literal: " foo [[-- \n<>\n
bar]]"[0m (0.32ms)
moves point
skip whitespace at the end of buffer: "<1> <2>"
[32m skip whitespace at the end of buffer: "<1> <2>"[0m (0.28ms)
skip ws before variable: "<1> <2>bar"
[32m skip ws before variable: "<1> <2>bar"[0m (0.28ms)
skip ws before function call: "foo<1> <2>()"
[32m skip ws before function call: "foo<1> <2>()"[0m (0.25ms)
skip newlines/tabs/spaces before variable: "<1> \n \n<2>foo"
[32m skip newlines/tabs/spaces before variable: "<1> \n
\n<2>foo"[0m (0.25ms)
escape single-line comment and skip ws: "foo -- <1>\n <2>bar"
[32m escape single-line comment and skip ws: "foo -- <1>\n <2>bar"[0m
(0.28ms)
escape single-line comment delimiter: "foo -<1>- \n <2>bar"
[32m escape single-line comment delimiter: "foo -<1>- \n <2>bar"[0m
(0.32ms)
escape commented out string and skip ws: "foo -- '<1>' \n <2>bar"
[32m escape commented out string and skip ws: "foo -- '<1>' \n
<2>bar"[0m (0.27ms)
escape commented out string and skip ws: "foo -- [[<1>]] \n <2>bar"
[32m escape commented out string and skip ws: "foo -- [[<1>]] \n
<2>bar"[0m (0.29ms)
skip single-line comment and ws: "foo <1>-- \n \n <2>bar"
[32m skip single-line comment and ws: "foo <1>-- \n \n <2>bar"[0m
(0.30ms)
skip several single-line comments and ws: "foo <1>-- \n--\n--\n \n
<2>bar"
[32m skip several single-line comments and ws: "foo <1>-- \n--\n--\n \n
<2>bar"[0m (0.29ms)
escape multi-line comment and skip ws: "foo --[[ <1> ]] <2>bar"
[32m escape multi-line comment and skip ws: "foo --[[ <1> ]] <2>bar"[0m
(0.35ms)
escape multi-line comment delimiter and skip ws 1: "foo -<1>-[[ ]]
<2>bar"
[32m escape multi-line comment delimiter and skip ws 1: "foo -<1>-[[ ]]
<2>bar"[0m (0.28ms)
escape multi-line comment delimiter and skip ws 2: "foo --<1>[[ ]]
<2>bar"
[32m escape multi-line comment delimiter and skip ws 2: "foo --<1>[[ ]]
<2>bar"[0m (0.27ms)
escape multi-line comment delimiter and skip ws 3: "foo --[<1>[ ]]
<2>bar"
[32m escape multi-line comment delimiter and skip ws 3: "foo --[<1>[ ]]
<2>bar"[0m (0.36ms)
escape multi-line comment delimiter and skip ws 4: "foo --[[ ]<1>]
<2>bar"
[32m escape multi-line comment delimiter and skip ws 4: "foo --[[ ]<1>]
<2>bar"[0m (0.26ms)
skip multi-line comments and ws: "foo <1>--[[ \n\n ]]\n\n--[[ ]] <2>bar"
[32m skip multi-line comments and ws: "foo <1>--[[ \n\n ]]\n\n--[[ ]]
<2>bar"[0m (0.31ms)
escape multi-line comment with luadoc keyword 1: "foo --[[ @see foo <1>]]
<2>bar"
[32m escape multi-line comment with luadoc keyword 1: "foo --[[ @see foo <1>]]
<2>bar"[0m (0.27ms)
escape multi-line comment with luadoc keyword 2: "foo --[[ @s<1>ee foo ]]
<2>bar"
[32m escape multi-line comment with luadoc keyword 2: "foo --[[ @s<1>ee foo ]]
<2>bar"[0m (0.27ms)
escape multi-line comment with luadoc keyword 3: "foo --[[ <1>@see foo ]]
<2>bar"
[32m escape multi-line comment with luadoc keyword 3: "foo --[[ <1>@see foo ]]
<2>bar"[0m (0.29ms)
escape single-line comment with luadoc keyword 1: "foo -- @see foo<1> \n
<2>bar"
[32m escape single-line comment with luadoc keyword 1: "foo -- @see foo<1> \n
<2>bar"[0m (0.28ms)
escape single-line comment with luadoc keyword 2: "foo -- @s<1>ee foo \n
<2>bar"
[32m escape single-line comment with luadoc keyword 2: "foo -- @s<1>ee foo \n
<2>bar"[0m (0.28ms)
escape single-line comment with luadoc keyword 3: "foo -- <1>@see foo \n
<2>bar"
[32m escape single-line comment with luadoc keyword 3: "foo -- <1>@see foo \n
<2>bar"[0m (0.27ms)
respects limit
in whitespace: limit=6 " <1> <2> "
[32m in whitespace: limit=6 " <1> <2> "[0m (0.27ms)
don't move if limit is before point: limit=1 " <2><1> "
[32m don't move if limit is before point: limit=1 " <2><1> "[0m
(0.27ms)
when escaping single-line comment 1: limit=8 "-- <1> <2> \n"
[32m when escaping single-line comment 1: limit=8 "-- <1> <2> \n"[0m
(0.25ms)
when escaping single-line comment 2: limit=8 "-- <1> \n<2> "
[32m when escaping single-line comment 2: limit=8 "-- <1> \n<2> "[0m
(0.25ms)
when escaping single-line comment 3: limit=8 "-- <1> <2>\n "
[32m when escaping single-line comment 3: limit=8 "-- <1> <2>\n "[0m
(0.25ms)
when escaping multi-line comment 1: limit=8 "--[[<1> <2> ]] \n"
[32m when escaping multi-line comment 1: limit=8 "--[[<1> <2> ]] \n"[0m
(0.26ms)
when escaping multi-line comment 1: limit=8 "--[[<1> ]<2>] \n"
[32m when escaping multi-line comment 1: limit=8 "--[[<1> ]<2>] \n"[0m
(0.26ms)
when escaping multi-line comment 1: limit=8 "--[[<1> <2> ]] \n"
[32m when escaping multi-line comment 1: limit=8 "--[[<1> <2> ]] \n"[0m
(0.27ms)
when escaping single-line luadoc comment: limit=7 "-- <1>@s<2>ee x "
[32m when escaping single-line luadoc comment: limit=7 "-- <1>@s<2>ee x
"[0m (0.24ms)
when escaping single-line luadoc comment: limit=8 "-- <1>@se<2>e x "
[32m when escaping single-line luadoc comment: limit=8 "-- <1>@se<2>e x
"[0m (0.25ms)
when escaping single-line luadoc comment: limit=9 "-- <1>@see<2> x "
[32m when escaping single-line luadoc comment: limit=9 "-- <1>@see<2> x
"[0m (0.25ms)
when escaping multi-line luadoc comment: limit=7 "--[[<1>@s<2>ee x]] "
[32m when escaping multi-line luadoc comment: limit=7 "--[[<1>@s<2>ee x]]
"[0m (0.27ms)
when escaping multi-line luadoc comment: limit=8 "--[[<1>@se<2>e x]] "
[32m when escaping multi-line luadoc comment: limit=8 "--[[<1>@se<2>e x]]
"[0m (0.30ms)
when escaping multi-line luadoc comment: limit=9 "--[[<1>@see<2> x]] "
[32m when escaping multi-line luadoc comment: limit=9 "--[[<1>@see<2> x]]
"[0m (0.27ms)
lua-find-regexp
does not match open-bracket that is part of multiline string opener: forward
[32m does not match open-bracket that is part of multiline string opener:
forward[0m (0.30ms)
does not match open-bracket that is part of multiline string opener: backward
[32m does not match open-bracket that is part of multiline string opener:
backward[0m (0.27ms)
does not match close-bracket that is part of multiline string closer: forward
[32m does not match close-bracket that is part of multiline string closer:
forward[0m (0.27ms)
does not match close-bracket that is part of multiline string closer: backward
[32m does not match close-bracket that is part of multiline string closer:
backward[0m (0.22ms)
does not match minus that is part of comment starter: forward
[32m does not match minus that is part of comment starter: forward[0m
(0.27ms)
does not match minus that is part of comment starter: backward
[32m does not match minus that is part of comment starter: backward[0m
(0.22ms)
========================================
[31mIndentation test `issue-33.lua' don't accumulate indentation after the
expression[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `issue-33.lua' here foobar should be indented as simple
continuation statement[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for single line
case[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for indenting all
args on one line: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for indenting all
args in a column: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for mixed arg
indentation: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works with table ctorfor
single line case[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works with table ctor
for indenting all args on one line: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works with table ctor
for indenting all args in a column: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works with table ctor
for mixed arg indentation: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for mixed arg
indentation with table in the middle: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for mixed arg
indentation with table first: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `function-call-arguments.lua' it works for mixed arg
indentation with table last: close paren on separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `only-use-last-opener.lua' nested table with indentation:
params after nested table[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block: 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block: 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block: 3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block: 4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block: 5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block: 6[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block:
single line 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block:
single line 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block:
single line 3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/then block:
single line 4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block: 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block: 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block: 3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block: 4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block: 5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block:
single line 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block:
single line 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block:
single line 3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block:
single line 4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/else block:
single line 6[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/elseif/else
block: 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `if-elseif-else-block.lua' works for if/elseif/else
block: 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 6[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: 7[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-equals-block.lua' works for "for ... = ... do"
block: single line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `smoke.lua' section 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' is sane[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' does not affect indentation when put on
a separate line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' does not affect indentation after block
modifiers[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
6[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `goto-label.lua' reindents according to luawiki examples:
7[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
6[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
7[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
8[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
9[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `for-in-block.lua' works for "for .. in .. do" block:
single line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `repeat-until-block.lua' works for repeat ... until
blocks: 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `repeat-until-block.lua' works for repeat ... until
blocks: 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `repeat-until-block.lua' works for repeat ... until
blocks: 3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `repeat-until-block.lua' works for repeat ... until
blocks: 4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `repeat-until-block.lua' works for repeat ... until
blocks: single line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `repeat-until-block.lua' works for repeat ... until
blocks: single line with continuation 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `do-block.lua' works for do ... end blocks on separate
lines[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `do-block.lua' works for do ... end blocks: single
line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `do-block.lua' works for do ... end blocks: body on the
same line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `do-block.lua' works for do ... end blocks: continuation
inside body[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `do-block.lua' works for do ... end blocks: parentheses
inside body[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
6[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
7[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
8[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
single line[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
single line with continuation in body[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `while-block.lua' works for while ... do ... end blocks:
single line with parentheses in body[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' ensure is sane[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' add continuation before =[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' add continuation after =[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after comma:
1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after comma:
2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after comma:
3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after comma:
4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after comma:
5[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after "local":
1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after "local":
2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after "local":
3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' continuation after "local":
4[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' indentation of function call
arguments in continuation part[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside parentheses: alignment 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside parentheses: alignment 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside parentheses: indentation 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside parentheses: indentation 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' it unindents close paren for
arithmetical expression[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' it unindents close paren for
arithmetical expression: local[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' it unindents close paren for
function call[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' it unindents close paren for
function call: local[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' it unindents close brace for
table ctor[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' it unindents close brace for
table ctor: local[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside brackets: alignment 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside brackets: alignment 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside brackets: indentation 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `assignment-indentation.lua' does not indent binary
operators inside brackets: indentation 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation if broken in the middle of
\"foo.bar\" and \"qux:quux\"[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation after return[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation after return:
blocks[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation after return: f1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation after return: f2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation after return: f3[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation after ellipsis[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation in block-intros:
while[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indentation in block-intros:
while 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indents expressions after
return: basic[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indents expressions after
return: function literal[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' indents expressions after
return: ellipsis[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: end[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: if/end[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: if/else[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: if/elseif[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: repeat/until[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: semicolon 1[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
========================================
[31mIndentation test `continuation-lines.lua' does not indents keywords after
return: semicolon 2[0m
Traceback (most recent call last):
cl--assertion-failed((eq 'closure (car-safe oclosure)))
error: (cl-assertion-failed ((eq 'closure (car-safe oclosure)) nil))
Ran 392 out of 410 specs, [31m133 failed[0m, in 158.17ms.
buttercup-run failed: ""
dh_elpa_test: error: buttercup -L . returned exit code 255
make: *** [debian/rules:4: build] Error 25
dpkg-buildpackage: error: debian/rules build subprocess returned exit status 2
--------------------------------------------------------------------------------
The above is just how the build ends and not necessarily the most relevant part.
If required, the full build log is available here:
https://people.debian.org/~sanvila/build-logs/202404/
About the archive rebuild: The build was made on virtual machines
of type m6a.large from AWS, using sbuild and a reduced chroot
with only build-essential packages.
If you could not reproduce the bug please contact me privately, as I
am willing to provide ssh access to a virtual machine where the bug is
fully reproducible.
If this is really a bug in one of the build-depends, please use
reassign and affects, so that this is still visible in the BTS web
page for this package.
Thanks.
