Detailed Test Report for ngx_stream_lua in linux x86_64 (v)

Summary
LuaJIT
OpenSSL
Compilation Error
Segmentation Faults
Unexpected Failures
Expected Failures
Warnings

Summary

Commit	Testing Time	Unexpected Failures	Expected Failures	Files	Tests	Elapsed Time
a5cd0c8c	2019-05-08 17:40:00 GMT	0	21	112	8945	2702 sec

LuaJIT

LuaJIT 2.1.0-beta3, commit 0e646b5

OpenSSL

OpenSSL 1.1.0j 20 Nov 2018

Compilation Errors

Segmentation Faults

Unexpected Failures

(none)

Expected Failures

File	Name	Details
106-timer.t	TEST 1: simple at - pattern "(?^:\[lua\] content_by_lua$nginx\.conf:\d+$:\d+: elapsed: 0\.0(?:4[4-9]\|5[0-6])\d*, context: ngx\.timer, client: \d+\.\d+\.\d+\.\d+, server: 0\.0\.0\.0:\d+)" should match a line in error.log (req 0)
106-timer.t	TEST 27: user args - pattern "(?^:\[lua\] content_by_lua$nginx\.conf:\d+$:\d+: elapsed: 0\.0(?:4[4-9]\|5[0-6])\d*, context: ngx\.timer)" should match a line in error.log (req 0)
106-timer.t	TEST 4: simple at (sleep in the timer callback) - pattern "(?^:\[lua\] content_by_lua$nginx\.conf:\d+$:\d+: elapsed: 0\.0(?:6[4-9]\|7[0-9]\|8[0-6]))" should match a line in error.log (req 0)
108-timer-safe.t	TEST 2: simple at (sleep in the timer callback) - pattern "(?^:\[lua\] content_by_lua$nginx\.conf:\d+$:\d+: elapsed: 0\.0(?:6[4-9]\|7[0-6]))" should match a line in error.log (req 0)
109-timer-hup.t	TEST 3: trying to add new timer after HUP reload - pattern "stream lua close fake stream connection" should match a line in error.log (req 0)
109-timer-hup.t	TEST 3: trying to add new timer after HUP reload - pattern "timer prematurely expired: true" should match a line in error.log (req 0)
109-timer-hup.t	TEST 3: trying to add new timer after HUP reload - pattern "failed to register a new timer after reload: process exiting, context: ngx.timer" should match a line in error.log (req 0)
109-timer-hup.t	TEST 7: HUP reload should abort pending timers (fuzz test) - grep_error_log_out (req 1)	got: 'stream lua found 8190 pending timers ' expected: 'stream lua found 8191 pending timers '
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "lua abort pending timers" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "lua ngx.timer expired" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "stream lua close fake stream connection" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "f: timer prematurely expired: true" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "f: registered a new timer after reload" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "f: exiting=true" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "g: timer prematurely expired: false" should match a line in error.log (req 0)
109-timer-hup.t	TEST 4: trying to add new timer after HUP reload - pattern "g: exiting=true" should match a line in error.log (req 0)
132-lua-blocks.t	nginx: [emerg]	"http" directive is not allowed here in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:28
132-lua-blocks.t	nginx: [emerg]	Lua code block missing the closing long bracket "]]" in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:22
132-lua-blocks.t	nginx: [emerg]	Lua code block missing the closing long bracket "]=]" in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:22
132-lua-blocks.t	nginx: [emerg]	Lua code block missing the closing long bracket "]]" in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:22
132-lua-blocks.t	nginx: [emerg]	Lua code block missing the closing long bracket "]==]" in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:22

Warnings

TEST 4: pcall safe - 2019/05/08 19:10:50 [warn] 10603#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: ngx.log in Lua files - 2019/05/08 19:11:38 [warn] 10639#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: ngx.log in Lua files - 2019/05/08 19:11:38 [warn] 10639#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('bar') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: ngx.log in Lua function tail-calls & inlined lua - 2019/05/08 19:11:51 [warn] 10645#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: ngx.log in Lua function tail-calls & inlined lua - 2019/05/08 19:11:51 [warn] 10645#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('bar') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: ngx.log in Lua function calls & inlined lua - 2019/05/08 19:12:03 [warn] 10651#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: ngx.log in Lua function calls & inlined lua - 2019/05/08 19:12:03 [warn] 10651#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('bar') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: md5_bin(number) - 2019/05/08 19:12:13 [warn] 10659#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: lua_code_cache off + setkeepalive - 2019/05/08 19:12:57 [warn] 10690#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: lua_code_cache off + setkeepalive - 2019/05/08 19:12:56 [alert] 10690#0: stream lua_code_cache is off; this will hurt performance in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:21
TEST 4: lua_code_cache off + setkeepalive - 2019/05/08 19:12:58 [warn] 10690#0: *8 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: lua_code_cache off + setkeepalive - 2019/05/08 19:12:58 [warn] 10690#0: *13 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: cosocket + stop - 2019/05/08 19:13:39 [warn] 10710#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: attempt to use the req socket across request boundary - 2019/05/08 19:14:07 [warn] 10728#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: receive until on request_body - receiveuntil(1) on the last byte of the body - 2019/05/08 19:14:13 [warn] 10731#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: variable (file) - 2019/05/08 19:14:21 [warn] 10738#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('v') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: variable - 2019/05/08 19:14:28 [warn] 10741#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('v') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:15:04 [warn] 10761#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: free up the whole connection pool if no active connections - 2019/05/08 19:15:07 [warn] 10762#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 23: cosocket connection pool timeout (before Lua VM destroys) - 2019/05/08 19:16:10 [warn] 10798#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 23: cosocket connection pool timeout (before Lua VM destroys) - 2019/05/08 19:16:10 [warn] 10798#0: *7 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: no clear builtin libs (misc) - 2019/05/08 19:16:19 [warn] 10802#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: no clear builtin libs (misc) - 2019/05/08 19:16:20 [warn] 10802#0: *5 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: no clear builtin libs (misc) - 2019/05/08 19:16:19 [warn] 10802#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: no clear builtin libs (misc) - 2019/05/08 19:16:20 [warn] 10802#0: *5 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: no clear builtin libs (misc) - 2019/05/08 19:16:20 [warn] 10802#0: *8 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: no clear builtin libs (misc) - 2019/05/08 19:16:20 [warn] 10802#0: *10 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 19:16:22 [warn] 10803#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 19:16:22 [warn] 10803#0: *7 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 19:16:22 [warn] 10803#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 19:16:22 [warn] 10803#0: *7 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 19:16:22 [warn] 10803#0: *10 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 19:16:22 [warn] 10803#0: *14 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: do not skip luarocks* - 2019/05/08 19:16:40 [warn] 10809#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('luarocks2') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: do not skip luarocks* - 2019/05/08 19:16:40 [warn] 10809#0: *10 stream [lua] _G write guard:12: writing a global lua variable ('luarocks2') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 19:16:45 [warn] 10811#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 19:16:45 [warn] 10811#0: *7 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 19:16:45 [warn] 10811#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 19:16:45 [warn] 10811#0: *7 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 19:16:45 [warn] 10811#0: *10 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 19:16:45 [warn] 10811#0: *14 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: do not skip luarocks - 2019/05/08 19:16:49 [warn] 10813#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('luarocks') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: do not skip luarocks - 2019/05/08 19:16:49 [warn] 10813#0: *10 stream [lua] _G write guard:12: writing a global lua variable ('luarocks') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: cosocket connection pool timeout (after Lua VM destroys) - 2019/05/08 19:16:54 [warn] 10815#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: cosocket connection pool timeout (after Lua VM destroys) - 2019/05/08 19:16:54 [warn] 10815#0: *7 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: clear _G table - 2019/05/08 19:17:01 [warn] 10818#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: clear _G table - 2019/05/08 19:17:01 [warn] 10818#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: ngx.encode_args (bad user data value) - 2019/05/08 19:17:15 [warn] 10828#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('err') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: ngx.encode_args (bad user data value) - 2019/05/08 19:17:15 [warn] 10828#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('rc') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: ngx.decode_args should not modify lua strings in place - 2019/05/08 19:17:32 [warn] 10836#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('args') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: case insensitive - 2019/05/08 19:17:51 [warn] 10855#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 21: match with ctx but no pos - 2019/05/08 19:18:00 [warn] 10859#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: multi-line mode (. does not match \n) - 2019/05/08 19:18:09 [warn] 10863#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: optional trailing captures - 2019/05/08 19:18:11 [warn] 10864#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:18:14 [warn] 10865#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: match with ctx and a pos - 2019/05/08 19:18:16 [warn] 10866#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: multiple captures (with o) - 2019/05/08 19:18:18 [warn] 10867#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: single-line mode (dot all) - 2019/05/08 19:18:23 [warn] 10869#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: case sensitive by default - 2019/05/08 19:18:29 [warn] 10872#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: case sensitive by default - 2019/05/08 19:18:30 [warn] 10872#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: UTF-8 mode - 2019/05/08 19:18:32 [warn] 10873#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('err') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: UTF-8 mode - 2019/05/08 19:18:32 [warn] 10873#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('rc') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: multi-line mode (^ at line head) - 2019/05/08 19:18:34 [warn] 10874#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 24: escaping sequences - 2019/05/08 19:18:38 [warn] 10876#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: single capture - 2019/05/08 19:18:40 [warn] 10877#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 27: long brackets containing [...] - 2019/05/08 19:18:43 [warn] 10878#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: extended mode (ignore whitespaces) - 2019/05/08 19:18:45 [warn] 10879#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: bad option - 2019/05/08 19:18:47 [warn] 10880#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: bad option - 2019/05/08 19:18:47 [warn] 10880#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('rc') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: extended mode (ignore whitespaces) - 2019/05/08 19:18:49 [warn] 10881#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: escaping sequences - 2019/05/08 19:18:51 [warn] 10882#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 42: extra table argument - 2019/05/08 19:18:54 [warn] 10883#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: multiple captures - 2019/05/08 19:18:56 [warn] 10884#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 25: long brackets - 2019/05/08 19:19:00 [warn] 10886#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 40: just hit match limit - 2019/05/08 19:19:03 [warn] 10887#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: anchored match (failed) - 2019/05/08 19:19:07 [warn] 10889#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: anchored match (failed) - 2019/05/08 19:19:07 [warn] 10889#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 20: anchored match (succeeded) - 2019/05/08 19:19:14 [warn] 10892#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: single-line mode (^ as normal) - 2019/05/08 19:19:18 [warn] 10894#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: single-line mode (^ as normal) - 2019/05/08 19:19:19 [warn] 10894#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: not matched - 2019/05/08 19:19:21 [warn] 10895#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: not matched - 2019/05/08 19:19:21 [warn] 10895#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 41: just not hit match limit - 2019/05/08 19:19:23 [warn] 10896#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: gmatch iterator used by another request - 2019/05/08 19:19:29 [warn] 10902#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 29: just hit match limit - 2019/05/08 19:19:32 [warn] 10903#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 21: gmatch with multiple named pattern - 2019/05/08 19:19:44 [warn] 10908#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: anchored match (failed) - 2019/05/08 19:19:46 [warn] 10909#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('it') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: gmatch matched but no iterate and early forced GC - 2019/05/08 19:19:49 [warn] 10910#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('it') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: gmatch with duplicate named pattern w/ extraction - 2019/05/08 19:19:53 [warn] 10912#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: gmatch with duplicate named pattern w/ extraction - 2019/05/08 19:19:54 [warn] 10912#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: gmatch with duplicate named pattern w/ extraction - 2019/05/08 19:19:54 [warn] 10912#0: *9 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: gmatch with duplicate named pattern w/ extraction - 2019/05/08 19:19:54 [warn] 10912#0: *12 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: gmatch with duplicate named pattern w/ extraction - 2019/05/08 19:19:54 [warn] 10912#0: *15 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 20: gmatch with named pattern - 2019/05/08 19:20:29 [warn] 10927#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 30: just not hit match limit - 2019/05/08 19:20:34 [warn] 10929#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 30: just not hit match limit - 2019/05/08 19:20:34 [warn] 10929#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 30: just not hit match limit - 2019/05/08 19:20:34 [warn] 10929#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 30: just not hit match limit - 2019/05/08 19:20:34 [warn] 10929#0: *9 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 30: just not hit match limit - 2019/05/08 19:20:34 [warn] 10929#0: *12 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 30: just not hit match limit - 2019/05/08 19:20:34 [warn] 10929#0: *15 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 27: just hit match limit - 2019/05/08 19:20:59 [warn] 10944#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 31: ngx.re.gsub: recursive calling (github #445) - 2019/05/08 19:21:25 [warn] 10956#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: just hit match limit - 2019/05/08 19:21:54 [warn] 10973#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: not matched - 2019/05/08 19:22:34 [warn] 10995#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: not matched - 2019/05/08 19:22:34 [warn] 10995#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: single-line mode (dot all) - 2019/05/08 19:22:36 [warn] 10996#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: single-line mode (^ as normal) - 2019/05/08 19:22:38 [warn] 10997#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: single-line mode (^ as normal) - 2019/05/08 19:22:38 [warn] 10997#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 20: match with ctx but no pos - 2019/05/08 19:22:40 [warn] 10998#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: extended mode (ignore whitespaces) - 2019/05/08 19:22:47 [warn] 11001#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: single capture - 2019/05/08 19:22:49 [warn] 11002#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:22:51 [warn] 11003#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: bad option - 2019/05/08 19:22:54 [warn] 11004#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: bad option - 2019/05/08 19:22:54 [warn] 11004#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('rc') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: anchored match (succeeded) - 2019/05/08 19:22:56 [warn] 11005#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: optional trailing captures - 2019/05/08 19:23:04 [warn] 11009#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: multi-line mode (. does not match \n) - 2019/05/08 19:23:07 [warn] 11010#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: case sensitive by default - 2019/05/08 19:23:09 [warn] 11011#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: case sensitive by default - 2019/05/08 19:23:09 [warn] 11011#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: case sensitive by default - 2019/05/08 19:23:11 [warn] 11012#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: escaping sequences - 2019/05/08 19:23:13 [warn] 11013#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: anchored match (failed) - 2019/05/08 19:23:18 [warn] 11015#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: anchored match (failed) - 2019/05/08 19:23:18 [warn] 11015#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: multiple captures - 2019/05/08 19:23:20 [warn] 11016#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 21: match with ctx and a pos - 2019/05/08 19:23:24 [warn] 11018#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: multi-line mode (^ at line head) - 2019/05/08 19:23:27 [warn] 11019#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: extended mode (ignore whitespaces) - 2019/05/08 19:23:31 [warn] 11021#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: set too large key - 2019/05/08 19:25:13 [warn] 11082#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 73: set & get_stale with a flag - 2019/05/08 19:27:31 [warn] 11146#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('flags') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: just hit match limit - 2019/05/08 19:28:11 [warn] 11175#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: not matched with j - 2019/05/08 19:28:14 [warn] 11176#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: not matched with j - 2019/05/08 19:28:14 [warn] 11176#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: not matched with jo - 2019/05/08 19:28:16 [warn] 11177#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: not matched with jo - 2019/05/08 19:28:16 [warn] 11177#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: matched with j - 2019/05/08 19:28:18 [warn] 11178#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: matched with jo - 2019/05/08 19:28:20 [warn] 11179#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: just not hit match limit - 2019/05/08 19:28:23 [warn] 11180#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: matched with d + j - 2019/05/08 19:28:25 [warn] 11184#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: not matched with do - 2019/05/08 19:28:29 [warn] 11186#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: not matched with do - 2019/05/08 19:28:29 [warn] 11186#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: matched with do - 2019/05/08 19:28:31 [warn] 11187#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: matched with d - 2019/05/08 19:28:34 [warn] 11188#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: not matched with j - 2019/05/08 19:28:38 [warn] 11190#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: not matched with j - 2019/05/08 19:28:38 [warn] 11190#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: flush wait in a user coroutine - 2019/05/08 19:30:30 [warn] 11283#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: exit in user thread (entry thread is still pending on ngx.flush) - 2019/05/08 19:30:37 [warn] 11289#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 40: u->coctx left over bug - 2019/05/08 19:30:53 [warn] 11296#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 46: bad request tries to receiveuntil - 2019/05/08 19:30:55 [warn] 11297#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 54: reuse cleanup in ngx.timer (fake_request) - 2019/05/08 19:31:13 [warn] 11305#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('i') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 42: bad request tries to receive - 2019/05/08 19:31:33 [warn] 11316#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 45: bad request tries to set keepalive - 2019/05/08 19:31:35 [warn] 11317#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: ngx.socket.connect (working) - 2019/05/08 19:31:38 [warn] 11318#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 41: bad request tries to connect - 2019/05/08 19:31:49 [warn] 11323#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: cannot survive across request boundary (send) - 2019/05/08 19:31:57 [warn] 11327#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 21: cannot survive across request boundary (close) - 2019/05/08 19:31:59 [warn] 11328#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 55: free cleanup in ngx.timer (without sock:close) - 2019/05/08 19:32:10 [warn] 11333#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('i') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 20: cannot survive across request boundary (receive) - 2019/05/08 19:32:14 [warn] 11335#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 44: bad request tries to close - 2019/05/08 19:32:25 [warn] 11340#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 43: bad request tries to send - 2019/05/08 19:32:36 [warn] 11345#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: raw memcached - 2019/05/08 19:32:58 [warn] 11363#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('resty') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:33:01 [warn] 11364#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('Memcached') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:33:01 [warn] 11364#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('CRC32') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:33:02 [warn] 11369#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('Redis') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: coroutine-based pub/sub - 2019/05/08 19:33:05 [warn] 11370#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('Redis') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: pcall works - 2019/05/08 19:33:32 [warn] 11390#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: xpcall works - 2019/05/08 19:33:34 [warn] 11391#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: xpcall works - 2019/05/08 19:33:34 [warn] 11391#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: xpcall works - 2019/05/08 19:33:34 [warn] 11391#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('h') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: xpcall works - 2019/05/08 19:33:34 [warn] 11391#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('err') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: exit in user thread (entry thread is still pending on tcpsock:send) - 2019/05/08 19:34:13 [warn] 11410#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: ambiguous boundary patterns (aaa) - 2019/05/08 19:34:30 [warn] 11420#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: ambiguous boundary patterns (aaa) - 2019/05/08 19:34:30 [warn] 11420#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: ambiguous boundary patterns (aa) - 2019/05/08 19:34:32 [warn] 11421#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: ambiguous boundary patterns (aa) - 2019/05/08 19:34:32 [warn] 11421#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: ambiguous boundary patterns (abcabdabcabe 3) - 2019/05/08 19:34:34 [warn] 11422#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: ambiguous boundary patterns (abcabdabcabe 3) - 2019/05/08 19:34:35 [warn] 11422#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: ambiguous boundary patterns (--abc), small buffer, mixed by other reading calls - 2019/05/08 19:34:39 [warn] 11424#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: ambiguous boundary patterns (--abc), small buffer, mixed by other reading calls - 2019/05/08 19:34:39 [warn] 11424#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: ambiguous boundary patterns (abcabdabcabe) - 2019/05/08 19:34:41 [warn] 11425#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: ambiguous boundary patterns (abcabdabcabe) - 2019/05/08 19:34:41 [warn] 11425#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: ambiguous boundary patterns (aaaaad) - 2019/05/08 19:34:45 [warn] 11427#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: ambiguous boundary patterns (aaaaad) - 2019/05/08 19:34:45 [warn] 11427#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: ambiguous boundary patterns (abcabd) - 2019/05/08 19:34:47 [warn] 11428#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: ambiguous boundary patterns (abcabd) - 2019/05/08 19:34:47 [warn] 11428#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: ambiguous boundary patterns (aaaaad), small buffer, 2 bytes - 2019/05/08 19:34:51 [warn] 11430#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: ambiguous boundary patterns (aaaaad), small buffer, 2 bytes - 2019/05/08 19:34:52 [warn] 11430#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: ambiguous boundary patterns (--abc) - 2019/05/08 19:34:54 [warn] 11431#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: ambiguous boundary patterns (--abc) - 2019/05/08 19:34:54 [warn] 11431#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: ambiguous boundary patterns (abcabd), small buffer - 2019/05/08 19:34:56 [warn] 11432#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: ambiguous boundary patterns (abcabd), small buffer - 2019/05/08 19:34:56 [warn] 11432#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: ambiguous boundary patterns (abcabdabcabe 2) - 2019/05/08 19:34:58 [warn] 11433#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: ambiguous boundary patterns (abcabdabcabe 2) - 2019/05/08 19:34:58 [warn] 11433#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: ambiguous boundary patterns (--abc), small buffer - 2019/05/08 19:35:00 [warn] 11434#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: ambiguous boundary patterns (--abc), small buffer - 2019/05/08 19:35:00 [warn] 11434#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: ambiguous boundary patterns (aaaaad), small buffer, 1 byte - 2019/05/08 19:35:04 [warn] 11436#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: ambiguous boundary patterns (aaaaad), small buffer, 1 byte - 2019/05/08 19:35:04 [warn] 11436#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: ambiguous boundary patterns (--abc) - 2019/05/08 19:35:06 [warn] 11437#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: ambiguous boundary patterns (--abc) - 2019/05/08 19:35:07 [warn] 11437#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: ambiguous boundary patterns (abcabdabcabe 4) - 2019/05/08 19:35:09 [warn] 11438#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: ambiguous boundary patterns (abcabdabcabe 4) - 2019/05/08 19:35:09 [warn] 11438#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: multipart rfc sample (just partial streaming) - 2019/05/08 19:35:12 [warn] 11443#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: multipart rfc sample (just partial streaming) - 2019/05/08 19:35:13 [warn] 11443#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: multipart rfc sample (completely streaming) - 2019/05/08 19:35:15 [warn] 11444#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: multipart rfc sample (completely streaming) - 2019/05/08 19:35:15 [warn] 11444#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('m') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: attempt to use the req socket across request boundary - 2019/05/08 19:35:17 [warn] 11445#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: receive until on request_body - receiveuntil(1) on the last byte of the body - 2019/05/08 19:35:19 [warn] 11446#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: pipelined POST requests - 2019/05/08 19:35:21 [warn] 11447#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: error(nil) - 2019/05/08 19:36:12 [warn] 11481#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('bar') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: error(nil) - 2019/05/08 19:36:12 [warn] 11481#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:36:17 [warn] 11483#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('bar') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: sanity - 2019/05/08 19:36:17 [warn] 11483#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: $prefix - 2019/05/08 19:36:18 [warn] 11487#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: ${prefix} - 2019/05/08 19:36:20 [warn] 11488#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: backtrace - 2019/05/08 19:36:47 [warn] 11504#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: backtrace - 2019/05/08 19:36:47 [warn] 11504#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('bar') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: globals shared - 2019/05/08 19:36:57 [warn] 11509#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: ambiguous boundary patterns (abcabd) - inclusive mode - small buffers - 2019/05/08 19:37:53 [warn] 11578#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: ambiguous boundary patterns (abcabd) - inclusive mode - small buffers - 2019/05/08 19:37:53 [warn] 11578#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: ambiguous boundary patterns (abcabd) - inclusive mode - 2019/05/08 19:37:57 [warn] 11580#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: ambiguous boundary patterns (abcabd) - inclusive mode - 2019/05/08 19:37:57 [warn] 11580#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: ambiguous boundary patterns (abcabdabcabe 4) - inclusive mode - 2019/05/08 19:37:59 [warn] 11581#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: ambiguous boundary patterns (abcabdabcabe 4) - inclusive mode - 2019/05/08 19:37:59 [warn] 11581#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: inclusive option value nil - 2019/05/08 19:38:03 [warn] 11583#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: inclusive option value nil - 2019/05/08 19:38:03 [warn] 11583#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: inclusive option value false - 2019/05/08 19:38:05 [warn] 11584#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: inclusive option value false - 2019/05/08 19:38:05 [warn] 11584#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: ambiguous boundary patterns (--abc), small buffer, mixed by other reading calls - 2019/05/08 19:38:07 [warn] 11585#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: ambiguous boundary patterns (--abc), small buffer, mixed by other reading calls - 2019/05/08 19:38:08 [warn] 11585#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: ambiguous boundary patterns (--abc), small buffer - 2019/05/08 19:38:10 [warn] 11586#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: ambiguous boundary patterns (--abc), small buffer - 2019/05/08 19:38:10 [warn] 11586#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: inclusive option value true (aa) - 2019/05/08 19:38:12 [warn] 11587#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: inclusive option value true (aa) - 2019/05/08 19:38:12 [warn] 11587#0: *8 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('line') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: access conflicts of connect() on shared udp objects - 2019/05/08 19:38:36 [warn] 11605#0: *4 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: bad request tries to send - 2019/05/08 19:38:38 [warn] 11606#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: bad request tries to send - 2019/05/08 19:38:38 [warn] 11606#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: bad request tries to send - 2019/05/08 19:38:38 [warn] 11606#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: bad request tries to send - 2019/05/08 19:38:38 [warn] 11606#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: access conflicts of receive() on shared udp objects - 2019/05/08 19:38:45 [warn] 11609#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: access conflicts of receive() on shared udp objects - 2019/05/08 19:38:45 [warn] 11609#0: *4 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: access conflicts of receive() on shared udp objects - 2019/05/08 19:38:45 [warn] 11609#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: access conflicts of receive() on shared udp objects - 2019/05/08 19:38:45 [warn] 11609#0: *4 stream [lua] _G write guard:12: writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: bad request tries to receive - 2019/05/08 19:38:47 [warn] 11610#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: bad request tries to receive - 2019/05/08 19:38:47 [warn] 11610#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: bad request tries to receive - 2019/05/08 19:38:47 [warn] 11610#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: bad request tries to receive - 2019/05/08 19:38:47 [warn] 11610#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: bad request tries to setpeer - 2019/05/08 19:38:58 [warn] 11619#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: bad request tries to setpeer - 2019/05/08 19:38:58 [warn] 11619#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: bad request tries to setpeer - 2019/05/08 19:38:58 [warn] 11619#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: bad request tries to setpeer - 2019/05/08 19:38:58 [warn] 11619#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: bad request tries to receive - 2019/05/08 19:39:06 [warn] 11627#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: bad request tries to close - 2019/05/08 19:39:12 [warn] 11630#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: basic coroutine print - 2019/05/08 19:39:32 [warn] 11649#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: basic coroutine2 - 2019/05/08 19:39:34 [warn] 11650#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: basic coroutine and cosocket - 2019/05/08 19:39:36 [warn] 11651#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('worker') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: coroutine.wrap(generate prime numbers) - 2019/05/08 19:39:39 [warn] 11652#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('gen') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: coroutine.wrap(generate prime numbers) - 2019/05/08 19:39:39 [warn] 11652#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('filter') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: coroutine.wrap(generate prime numbers) - 2019/05/08 19:39:39 [warn] 11652#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('N') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: coroutine.wrap(generate prime numbers) - 2019/05/08 19:39:39 [warn] 11652#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('x') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: coroutine.wrap(generate prime numbers,reset create and resume) - 2019/05/08 19:39:41 [warn] 11653#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('gen') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: coroutine.wrap(generate prime numbers,reset create and resume) - 2019/05/08 19:39:41 [warn] 11653#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('filter') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: coroutine.wrap(generate prime numbers,reset create and resume) - 2019/05/08 19:39:41 [warn] 11653#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('N') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: coroutine.wrap(generate prime numbers,reset create and resume) - 2019/05/08 19:39:41 [warn] 11653#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('x') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: coroutine.wrap(generate fib) - 2019/05/08 19:39:43 [warn] 11654#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('generatefib') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: coroutine wrap and cosocket - 2019/05/08 19:39:45 [warn] 11655#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('worker') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: coroutine status, running - 2019/05/08 19:39:47 [warn] 11656#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: bug: resume dead coroutine with args - 2019/05/08 19:39:56 [warn] 11660#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: bug: resume dead coroutine with args - 2019/05/08 19:39:56 [warn] 11660#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('co') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: deeply nested coroutines - 2019/05/08 19:39:58 [warn] 11661#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: deeply nested coroutines - 2019/05/08 19:39:58 [warn] 11661#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: using ngx.exit in user coroutines - 2019/05/08 19:40:00 [warn] 11662#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: using ngx.exit in user coroutines - 2019/05/08 19:40:00 [warn] 11662#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: resume coroutines from within another one that is not its parent - 2019/05/08 19:40:02 [warn] 11663#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: resume coroutines from within another one that is not its parent - 2019/05/08 19:40:02 [warn] 11663#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: infinite recursive calls of coroutine.resume - 2019/05/08 19:40:04 [warn] 11666#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: infinite recursive calls of coroutine.resume - 2019/05/08 19:40:04 [warn] 11666#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: resume running (user) coroutines - 2019/05/08 19:40:08 [warn] 11668#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: user coroutine end with errors, and the parent coroutine gets the right status - 2019/05/08 19:40:10 [warn] 11669#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: init_by_lua + our own coroutines in content_by_lua - 2019/05/08 19:40:17 [warn] 11672#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('worker') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 23: init_by_lua_file + our own coroutines in content_by_lua - 2019/05/08 19:40:19 [warn] 11673#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('worker') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 24: mixing coroutine.* API between init_by_lua and other contexts (github #304) - init_by_lua - 2019/05/08 19:40:21 [warn] 11674#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('generator') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 25: mixing coroutine.* API between init_by_lua and other contexts (github #304) - init_by_lua_file - 2019/05/08 19:40:23 [warn] 11675#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('generator') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 26: coroutine context collicisions - 2019/05/08 19:40:25 [warn] 11676#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 27: require "coroutine" - 2019/05/08 19:40:27 [warn] 11677#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: two user threads flushing at the same time - 2019/05/08 19:40:29 [warn] 11681#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: two user threads flushing at the same time - 2019/05/08 19:40:29 [warn] 11681#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: coroutine status of a "normal" user thread - 2019/05/08 19:40:31 [warn] 11682#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: coroutine status of a "normal" user thread - 2019/05/08 19:40:31 [warn] 11682#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: simple user thread with args - 2019/05/08 19:40:33 [warn] 11683#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: error in user thread - 2019/05/08 19:40:36 [warn] 11684#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: coroutine status of a running user thread - 2019/05/08 19:40:38 [warn] 11685#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: manual time slicing between two user threads - 2019/05/08 19:40:40 [warn] 11686#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: manual time slicing between two user threads - 2019/05/08 19:40:40 [warn] 11686#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: nested user threads (with I/O) - 2019/05/08 19:40:42 [warn] 11687#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: nested user threads (with I/O) - 2019/05/08 19:40:42 [warn] 11687#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: simple user thread without I/O - 2019/05/08 19:40:44 [warn] 11688#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: nested user threads - 2019/05/08 19:40:46 [warn] 11689#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: nested user threads - 2019/05/08 19:40:46 [warn] 11689#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: user threads + ngx.socket.tcp - 2019/05/08 19:40:48 [warn] 11690#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: two simple user threads with sleep - 2019/05/08 19:40:51 [warn] 11691#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: two simple user threads with sleep - 2019/05/08 19:40:51 [warn] 11691#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 20: simple user thread without I/O - 2019/05/08 19:40:53 [warn] 11692#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: creating user threads in a user coroutine - 2019/05/08 19:40:56 [warn] 11693#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: creating user threads in a user coroutine - 2019/05/08 19:40:56 [warn] 11693#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: user threads + ngx.socket.udp - 2019/05/08 19:40:58 [warn] 11694#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: simple user thread with ngx.req.socket() - 2019/05/08 19:41:00 [warn] 11699#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: coroutine status of a dead user thread - 2019/05/08 19:41:02 [warn] 11700#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: two simple user threads without I/O - 2019/05/08 19:41:04 [warn] 11701#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: two simple user threads without I/O - 2019/05/08 19:41:04 [warn] 11701#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: entry thread and a user thread flushing at the same time - 2019/05/08 19:41:06 [warn] 11702#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: manual time slicing between a user thread and the entry thread - 2019/05/08 19:41:08 [warn] 11703#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: simple user thread with sleep - 2019/05/08 19:41:10 [warn] 11704#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: exit in a user thread (another user thread is still pending on ngx.sleep) - 2019/05/08 19:41:12 [warn] 11708#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: exit in a user thread (another user thread is still pending on ngx.sleep) - 2019/05/08 19:41:12 [warn] 11708#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: exit in user thread (entry thread is still pending on tcpsock:receive) - 2019/05/08 19:41:14 [warn] 11709#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: exit in user thread (entry thread is still pending on the DNS resolver for ngx.socket.tcp) - 2019/05/08 19:41:17 [warn] 11710#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: exit in user thread (entry thread is still pending on the DNS resolver for ngx.socket.tcp) - 2019/05/08 19:41:17 [alert] 11710#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 2: exit in user thread (entry thread is still pending on ngx.sleep) - 2019/05/08 19:41:19 [warn] 11711#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: exit in user thread (entry thread is still pending on udpsock:receive) - 2019/05/08 19:41:21 [warn] 11712#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: exit in user thread (entry already quits) - 2019/05/08 19:41:23 [warn] 11713#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: exit in user thread (entry thread is still pending on the DNS resolver for ngx.socket.udp) - 2019/05/08 19:41:26 [warn] 11714#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: exit in user thread (entry thread is still pending on the DNS resolver for ngx.socket.udp) - 2019/05/08 19:41:26 [alert] 11714#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 7: exit in user thread (entry thread is still pending on tcpsock:connect) - 2019/05/08 19:41:28 [warn] 11715#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: exit in user thread (entry thread is still pending on tcpsock:receiveuntil's iterator) - 2019/05/08 19:41:30 [warn] 11716#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: exit in user thread (entry thread is still pending on reqsock:receive) - 2019/05/08 19:41:32 [warn] 11717#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: exit in user thread (entry thread is still pending to run) - 2019/05/08 19:41:35 [warn] 11718#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: waiting on two simple user threads with I/O - 2019/05/08 19:41:37 [warn] 11722#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: waiting on two simple user threads with I/O - 2019/05/08 19:41:37 [warn] 11722#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 5: simple user thread wait without I/O (return multiple values) - 2019/05/08 19:41:39 [warn] 11723#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: wait on uthreads on the reversed order of their termination - 2019/05/08 19:41:41 [warn] 11724#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: wait on uthreads on the reversed order of their termination - 2019/05/08 19:41:41 [warn] 11724#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: simple user thread wait without I/O (in a user coroutine) - 2019/05/08 19:41:44 [warn] 11725#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: simple user thread wait without I/O (in a user coroutine) - 2019/05/08 19:41:44 [warn] 11725#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: wait on uthreads on the exact order of their termination - 2019/05/08 19:41:46 [warn] 11726#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: wait on uthreads on the exact order of their termination - 2019/05/08 19:41:46 [warn] 11726#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: wait on uthreads on the exact order of their termination - 2019/05/08 19:41:46 [warn] 11726#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: wait on uthreads on the exact order of their termination - 2019/05/08 19:41:46 [warn] 11726#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 21: waiting on a dead coroutine - 2019/05/08 19:41:48 [warn] 11727#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 19: entry coroutine waiting on a user coroutine - 2019/05/08 19:41:51 [warn] 11728#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: simple user thread wait without I/O - 2019/05/08 19:41:53 [warn] 11729#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: simple user thread wait with I/O (in a user coroutine) - 2019/05/08 19:41:55 [warn] 11730#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: simple user thread wait with I/O (in a user coroutine) - 2019/05/08 19:41:55 [warn] 11730#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 20: lua backtrace dumper may access dead parent coroutines - 2019/05/08 19:41:57 [warn] 11731#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: wait on uthreads on the reversed order of their termination, but exit the world early - 2019/05/08 19:41:59 [warn] 11732#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: wait on uthreads on the reversed order of their termination, but exit the world early - 2019/05/08 19:41:59 [warn] 11732#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: wait on uthreads on the reversed order of their termination, but exit the world early - 2019/05/08 19:42:00 [warn] 11732#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 17: wait on uthreads on the reversed order of their termination, but exit the world early - 2019/05/08 19:42:00 [warn] 11732#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: wait on uthreads on the exact order of their termination, but exit the world early - 2019/05/08 19:42:02 [warn] 11733#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: wait on uthreads on the exact order of their termination, but exit the world early - 2019/05/08 19:42:02 [warn] 11733#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: wait on uthreads on the exact order of their termination, but exit the world early - 2019/05/08 19:42:02 [warn] 11733#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('res') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 16: wait on uthreads on the exact order of their termination, but exit the world early - 2019/05/08 19:42:02 [warn] 11733#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: waiting on two simple user threads without I/O, both aborted by errors - 2019/05/08 19:42:04 [warn] 11734#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 14: waiting on two simple user threads without I/O, both aborted by errors - 2019/05/08 19:42:04 [warn] 11734#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: simple user thread wait with I/O, throw errors - 2019/05/08 19:42:08 [warn] 11736#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: simple user thread wait with I/O, return multiple values - 2019/05/08 19:42:10 [warn] 11737#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: simple user thread wait without I/O, throw errors - 2019/05/08 19:42:13 [warn] 11738#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: spawn and wait uthreads for many times - 2019/05/08 19:42:15 [warn] 11739#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: waiting on two simple user threads without I/O - 2019/05/08 19:42:17 [warn] 11740#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: waiting on two simple user threads without I/O - 2019/05/08 19:42:17 [warn] 11740#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: simple user thread wait with I/O - 2019/05/08 19:42:19 [warn] 11741#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: waiting on two simple user threads with I/O, both aborted by errors - 2019/05/08 19:42:22 [warn] 11742#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: waiting on two simple user threads with I/O, both aborted by errors - 2019/05/08 19:42:22 [warn] 11742#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: entry coroutine waiting on a thread not created by itself - 2019/05/08 19:42:24 [warn] 11743#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 18: entry coroutine waiting on a thread not created by itself - 2019/05/08 19:42:24 [warn] 11743#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: waiting on two simple user threads with I/O (uthreads completed in reversed order) - 2019/05/08 19:42:26 [warn] 11744#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 13: waiting on two simple user threads with I/O (uthreads completed in reversed order) - 2019/05/08 19:42:26 [warn] 11744#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('g') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 11: cosocket + stop - 2019/05/08 19:42:53 [warn] 11759#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('ok') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: separated global env - 2019/05/08 19:44:27 [warn] 11799#0: *4 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 12: ngx.thread API - 2019/05/08 19:44:46 [warn] 11811#0: *4 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: tcp cosocket in timer handler (keep-alive connections) - 2019/05/08 19:44:48 [warn] 11812#0: *4 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: ngx.thread API - 2019/05/08 19:45:21 [warn] 11832#0: *4 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: tcp cosocket in timer handler (keep-alive connections) - 2019/05/08 19:45:31 [warn] 11836#0: *4 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 22: just hit match limit - 2019/05/08 19:46:52 [warn] 12057#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 23: just not hit match limit - 2019/05/08 19:47:50 [warn] 12083#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: fuzz testing - 2019/05/08 19:49:00 [warn] 12141#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('sz') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 10: fuzz testing - 2019/05/08 19:49:00 [warn] 12141#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('val') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: already waited - 2019/05/08 19:49:13 [warn] 12148#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: kill pending connect - 2019/05/08 19:49:15 [warn] 12149#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: kill self - 2019/05/08 19:49:17 [warn] 12150#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: kill pending resolver - 2019/05/08 19:49:19 [warn] 12151#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: kill pending resolver - 2019/05/08 19:49:19 [alert] 12151#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 3: kill pending resolver - 2019/05/08 19:49:20 [alert] 12151#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 5: kill a thread already terminated - 2019/05/08 19:49:22 [warn] 12152#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 1: kill pending sleep - 2019/05/08 19:49:24 [warn] 12153#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: concurrent operations while resolving - 2019/05/08 19:49:30 [alert] 12159#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 6: concurrent operations while resolving - 2019/05/08 19:49:31 [alert] 12159#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
killing the child process 12168 with force... at /home/ec2-user/git/stream-lua-nginx-module/../test-nginx/lib/Test/Nginx/Util.pm line 608.
killing the child process 12169 with force... at /home/ec2-user/git/stream-lua-nginx-module/../test-nginx/lib/Test/Nginx/Util.pm line 608.
TEST 17: unsupported ssl protocol - 2019/05/08 19:50:58 [crit] 12195#0: *3 SSL_do_handshake() failed (SSL: error:141640BF:SSL routines:tls_construct_client_hello:no protocols available), client: 127.0.0.1, server: 0.0.0.0:1985
TEST 17: unsupported ssl protocol - 2019/05/08 19:50:58 [crit] 12195#0: *8 SSL_do_handshake() failed (SSL: error:141640BF:SSL routines:tls_construct_client_hello:no protocols available), client: 127.0.0.1, server: 0.0.0.0:1985
TEST 8: all in one - 2019/05/08 19:51:39 [warn] 12219#0: *4 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('s') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 15: simple user thread wait with yielding - 2019/05/08 19:53:29 [warn] 12306#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('f') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 2: pipelined POST requests - 2019/05/08 19:53:57 [warn] 12327#0: *3 stream [lua] _G write guard:12: writing a global lua variable ('test') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: warn messages for polluting _G table when handling request - 2019/05/08 19:54:07 [warn] 12335#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 9: warn messages for polluting _G table when handling request - 2019/05/08 19:54:07 [warn] 12335#0: *6 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('1') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 6: timer - 2019/05/08 19:54:09 [warn] 12336#0: *4 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 3: preread_by_lua - 2019/05/08 19:54:13 [warn] 12338#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 4: content_by_lua - 2019/05/08 19:54:15 [warn] 12339#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: balancer_by_lua - 2019/05/08 19:54:17 [warn] 12340#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 8: balancer_by_lua - 2019/05/08 19:54:17 [crit] 12340#0: *3 connect() to 0.0.0.1:1234 failed (22: Invalid argument) while connecting to upstream, client: 127.0.0.1, server: 0.0.0.0:1985, upstream: \"0.0.0.1:1234\", bytes from/to client:0/0, bytes from/to upstream:0/0
TEST 8: balancer_by_lua - 2019/05/08 19:54:17 [crit] 12340#0: *7 connect() to 0.0.0.1:1234 failed (22: Invalid argument) while connecting to upstream, client: 127.0.0.1, server: 0.0.0.0:1985, upstream: \"0.0.0.1:1234\", bytes from/to client:0/0, bytes from/to upstream:0/0
TEST 5: log_by_lua - 2019/05/08 19:54:21 [warn] 12342#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables
TEST 7: uthread - 2019/05/08 19:54:23 [warn] 12343#0: *3 stream [lua] _G write guard:12: __newindex(): writing a global lua variable ('foo') which may lead to race conditions between concurrent requests, so prefer the use of 'local' variables

Go back to the index page.