Your message dated Sat, 20 Apr 2024 06:49:26 +0000
with message-id <[email protected]>
and subject line Bug#1069073: fixed in lua-mode 20210802-4
has caused the Debian Bug report #1069073,
regarding lua-mode: FTBFS: failing tests
to be marked as done.
This means that you claim that the problem has been dealt with.
If this is not the case it is now your responsibility to reopen the
Bug report if necessary, and/or fix the problem forthwith.
(NB: If you are a system administrator and have no idea what this
message is talking about, this may indicate a serious mail system
misconfiguration somewhere. Please contact [email protected]
immediately.)
--
1069073: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1069073
Debian Bug Tracking System
Contact [email protected] with problems
--- Begin Message ---
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.
--- End Message ---
--- Begin Message ---
Source: lua-mode
Source-Version: 20210802-4
Done: Sean Whitton <[email protected]>
We believe that the bug you reported is fixed in the latest version of
lua-mode, which is due to be installed in the Debian FTP archive.
A summary of the changes between this version and the previous one is
attached.
Thank you for reporting the bug, which will now be closed. If you
have further comments please address them to [email protected],
and the maintainer will reopen the bug report if appropriate.
Debian distribution maintenance software
pp.
Sean Whitton <[email protected]> (supplier of updated lua-mode package)
(This message was generated automatically at their request; if you
believe that there is a problem with it please contact the archive
administrators by mailing [email protected])
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512
Format: 1.8
Date: Sat, 20 Apr 2024 07:28:11 +0100
Source: lua-mode
Architecture: source
Version: 20210802-4
Distribution: unstable
Urgency: medium
Maintainer: Debian Emacsen Team <[email protected]>
Changed-By: Sean Whitton <[email protected]>
Closes: 1069073
Changes:
lua-mode (20210802-4) unstable; urgency=medium
.
[ Xiyue Deng ]
* Mark lexical binding patch as Forwarded and Applied-Upstream
* Add patch to use eval in lexical scope to fix tests (Closes: #1069073)
* Keep test/*.el in d/elpa-test to make autopkgtest work
* Add Upstream-Contact in d/copyright
* Update homepage to github page in d/control (old link no longer works)
* Set Rules-Requires-Root to no in d/control
* Drop Built-Using from binary package in d/control as it was not needed
for license or DFSG purpose
* Trim trailing whitespace in d/changelog
* Bump debhelper from old 10 to 13
* Set debhelper-compat version in Build-Depends
* Set upstream metadata fields: Bug-Database, Bug-Submit, Repository,
Repository-Browse
* Update Standards-Version to 4.7.0; no change needed
* Modernize d/watch with substitute strings to be more robust
* Add myself to uploaders
Checksums-Sha1:
b1dbcc63967cca81504dea52afe83aebee96bc10 2118 lua-mode_20210802-4.dsc
aea2b74be94e823b3a751ff399635c547fabe5dd 5728 lua-mode_20210802-4.debian.tar.xz
Checksums-Sha256:
163b84eea2e8890f60c5022cda0046be3e2622769a91c87fc5de710447ebc2b6 2118
lua-mode_20210802-4.dsc
fd64ba679fd3391567e81e1449fc59bfa81a99d46c61a225e6bd5aeb436bb0ee 5728
lua-mode_20210802-4.debian.tar.xz
Files:
6f5a685a8c19441e9d07de97c8e69197 2118 lisp optional lua-mode_20210802-4.dsc
9ffba2749d3bb44afa6c48bd360f0794 5728 lisp optional
lua-mode_20210802-4.debian.tar.xz
-----BEGIN PGP SIGNATURE-----
iQIzBAEBCgAdFiEEm5FwB64DDjbk/CSLaVt65L8GYkAFAmYjYQAACgkQaVt65L8G
YkCRMhAAoI0buxt2mH13pPEAPQGC6gjvdZQiJ79TbyLYVxkiYHlOzvLbDyVR3axZ
aQcjoIRgzd2xQLOojKSyJ0V/aMkrQgwtgTqR1WLfmwuG9L2hVzb5TkTW6DvyUWsz
QoP0CzxFY1uafjS7PpFPpm3e6AA6abuqdfbbm57sYp10mZJrizvAGgkPGMUadD6h
RlGhq3b3hasfD+z+Hsf9KEOJJtgAwyB2IdmTCANUfEb0r63i9ayFmkRobQik121U
WGC5TZ5osDrK2K2evCrJsboaW5DhfR9GVoiKWxruakuyZ8m7zdEmbMaKkzTnmOq/
5jOwD74AbAMVX1xLWhbvM5rMeqLvD8WXK3tehWowLaAC3TIKl2Eakjt3NNFGBjXM
2806ZglNY9mQeae+f5Z8AlrBJy3fVPCnhp0o9MYd3Tab8Y7z8HYPEZUHn1OGv+bk
7DNbFXLLWjROWtV39hlTxiaXh3ReATAGVmabHRrjA93yc+7Pi3FfZ/JLwKSLEEiw
zd7myUANM+j7m+7IyQsT3EUE3c+0bU6qPNCeExRIHqAHOZPPIDPNkkm0fE4Kad6M
gR9fksJ/5+2AWqWfzSC0lmc9wlpm03xCnFCS0Fn9KvGElRbFLdxfUr30VZyLMf8l
2atTdcbHgqCFgGlcQtEILp6IWcWlCyaES6bU7x2RyPmcF7YJrYo=
=SKBK
-----END PGP SIGNATURE-----
pgpiidCDgkbyy.pgp
Description: PGP signature
--- End Message ---
