Detailed Test Report for ngx_stream_lua in linux x86_64 (w)

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	18	112	8945	433 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
005-exit.t	TEST 2: throw error after sending the header and partial body - response_body - response is expected (repeated req 0, req 0)	got: 'h' expected: 'hi '
005-exit.t	TEST 2: throw error after sending the header and partial body - response_body - response is expected (repeated req 1, req 0)	got: 'h' expected: 'hi '
056-flush.t	TEST 1: flush wait - content - pattern "lua reuse free buf memory 13 >= 5" should match a line in error.log (req 0)
056-flush.t	TEST 1: flush wait - content - pattern "lua reuse free buf memory 13 >= 5" should match a line in error.log (req 1)
058-tcp-socket.t	TEST 28: send tables of string fragments (bad type ngx.null) - response_body - response is expected (repeated req 0, req 0)	got: 'c' expected: 'connected: 1 '
058-tcp-socket.t	TEST 28: send tables of string fragments (bad type ngx.null) - response_body - response is expected (repeated req 1, req 0)	got: 'c' expected: 'connected: 1 '
058-tcp-socket.t	TEST 26: send tables of string fragments (bad type "nil") - response_body - response is expected (repeated req 0, req 0)	got: 'c' expected: 'connected: 1 '
058-tcp-socket.t	TEST 26: send tables of string fragments (bad type "nil") - response_body - response is expected (repeated req 1, req 0)	got: 'c' expected: 'connected: 1 '
058-tcp-socket.t	TEST 27: send tables of string fragments (bad type "boolean") - response_body - response is expected (repeated req 0, req 0)	got: 'c' expected: 'connected: 1 '
058-tcp-socket.t	TEST 27: send tables of string fragments (bad type "boolean") - response_body - response is expected (repeated req 1, req 0)	got: 'c' expected: 'connected: 1 '
100-client-abort.t	TEST 17: ngx.print - pattern "print failed: nginx output filter error" should match a line in error.log (req 0)
100-client-abort.t	TEST 17: ngx.print - pattern "print failed: nginx output filter error" should match a line in error.log (req 1)
100-client-abort.t	TEST 16: ngx.say - pattern "say failed: nginx output filter error" should match a line in error.log (req 0)
100-client-abort.t	TEST 16: ngx.say - pattern "say failed: nginx output filter error" should match a line in error.log (req 1)
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]	"http" directive is not allowed here in /home/ec2-user/git/stream-lua-nginx-module/t/servroot/conf/nginx.conf:28

Warnings

TEST 4: pcall safe - 2019/05/08 20:57:20 [warn] 12480#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: ngx.log in Lua function tail-calls & inlined lua - 2019/05/08 20:57:24 [warn] 12558#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 20:57:24 [warn] 12558#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 20:57:24 [warn] 12564#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 20:57:24 [warn] 12564#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 16: ngx.log in Lua files - 2019/05/08 20:57:25 [warn] 12573#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 20:57:25 [warn] 12573#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 20:57:27 [warn] 12615#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 20:57:30 [warn] 12681#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 20:57:30 [alert] 12680#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 20:57:30 [warn] 12681#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 20:57:31 [warn] 12681#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 20:57:47 [warn] 12735#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 20:57:51 [warn] 12759#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 20:57:54 [warn] 12789#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: variable - 2019/05/08 20:57:57 [warn] 12819#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 5: variable (file) - 2019/05/08 20:57:58 [warn] 12828#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 20:58:08 [warn] 12858#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 20:58:08 [warn] 12861#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 20:58:17 [warn] 12951#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 20:58:17 [warn] 12951#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 22: cosocket connection pool timeout (after Lua VM destroys) - 2019/05/08 20:58:18 [warn] 12957#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 20:58:18 [warn] 12957#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 6: code cache explicitly off (affects require) + content_by_lua - 2019/05/08 20:58:23 [warn] 12969#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 20:58:23 [warn] 12969#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 20:58:23 [warn] 12969#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 20:58:23 [warn] 12969#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 20:58:23 [warn] 12969#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 20:58:23 [warn] 12969#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 20:58:23 [warn] 12972#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 20:58:23 [warn] 12972#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 12: do not skip luarocks* - 2019/05/08 20:58:23 [warn] 12978#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 20:58:23 [warn] 12978#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 13: clear _G table - 2019/05/08 20:58:25 [warn] 12996#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 20:58:25 [warn] 12996#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: code cache explicitly off (affects require) + content_by_lua_file - 2019/05/08 20:58:25 [warn] 12999#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 20:58:25 [warn] 12999#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 20:58:25 [warn] 12999#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 20:58:25 [warn] 12999#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 20:58:25 [warn] 12999#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 20:58:25 [warn] 12999#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 10: no clear builtin libs (misc) - 2019/05/08 20:58:26 [warn] 13005#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 20:58:26 [warn] 13005#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 20:58:26 [warn] 13005#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 20:58:26 [warn] 13005#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 20:58:26 [warn] 13005#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 20:58:26 [warn] 13005#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 7: ngx.encode_args (bad user data value) - 2019/05/08 20:58:27 [warn] 13017#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 20:58:27 [warn] 13017#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 20:58:28 [warn] 13041#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 10: multi-line mode (^ at line head) - 2019/05/08 20:58:30 [warn] 13098#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 20:58:31 [warn] 13104#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 25: long brackets - 2019/05/08 20:58:31 [warn] 13107#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 20:58:31 [warn] 13116#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 20:58:32 [warn] 13128#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 20:58:32 [warn] 13131#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 20:58:33 [warn] 13137#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 20:58:33 [warn] 13140#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 20:58:33 [warn] 13146#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 14: extended mode (ignore whitespaces) - 2019/05/08 20:58:33 [warn] 13149#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 8: case insensitive - 2019/05/08 20:58:34 [warn] 13152#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 20:58:34 [warn] 13158#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 20:58:34 [warn] 13164#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 20:58:34 [warn] 13164#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 24: escaping sequences - 2019/05/08 20:58:35 [warn] 13173#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 20: anchored match (succeeded) - 2019/05/08 20:58:35 [warn] 13176#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 20:58:35 [warn] 13179#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 41: just not hit match limit - 2019/05/08 20:58:36 [warn] 13185#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 9: UTF-8 mode - 2019/05/08 20:58:36 [warn] 13188#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 20:58:36 [warn] 13188#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 2: escaping sequences - 2019/05/08 20:58:36 [warn] 13191#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 20:58:36 [warn] 13194#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 20:58:36 [warn] 13197#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 20:58:36 [warn] 13200#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 20:58:37 [warn] 13203#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 20:58:37 [warn] 13203#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 20:58:37 [warn] 13209#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 20:58:37 [warn] 13209#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 20:58:37 [warn] 13215#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 20:58:37 [warn] 13215#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 42: extra table argument - 2019/05/08 20:58:38 [warn] 13218#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 20:58:38 [warn] 13221#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 20:58:38 [warn] 13221#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 20: gmatch with named pattern - 2019/05/08 20:58:40 [warn] 13245#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: gmatch matched but no iterate and early forced GC - 2019/05/08 20:58:41 [warn] 13248#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 20:58:41 [warn] 13254#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 20:58:41 [warn] 13254#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 20:58:41 [warn] 13254#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 20:58:42 [warn] 13254#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 20:58:42 [warn] 13254#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 5: anchored match (failed) - 2019/05/08 20:58:42 [warn] 13263#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 30: just not hit match limit - 2019/05/08 20:58:43 [warn] 13266#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 20:58:43 [warn] 13266#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 20:58:43 [warn] 13266#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 20:58:43 [warn] 13266#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 20:58:43 [warn] 13266#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 20:58:43 [warn] 13266#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 21: gmatch with multiple named pattern - 2019/05/08 20:58:43 [warn] 13269#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 29: just hit match limit - 2019/05/08 20:58:44 [warn] 13272#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 20:58:44 [warn] 13278#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 27: just hit match limit - 2019/05/08 20:58:50 [warn] 13326#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 20:58:52 [warn] 13377#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 20:58:58 [warn] 13471#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: multi-line mode (. does not match \n) - 2019/05/08 20:58:59 [warn] 13495#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 20:58:59 [warn] 13501#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 20:58:59 [warn] 13504#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 20:58:59 [warn] 13504#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 11: single-line mode (^ as normal) - 2019/05/08 20:58:59 [warn] 13507#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 20:58:59 [warn] 13507#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: multi-line mode (^ at line head) - 2019/05/08 20:59:00 [warn] 13510#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 20: match with ctx but no pos - 2019/05/08 20:59:00 [warn] 13516#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 20:59:00 [warn] 13519#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 20:59:00 [warn] 13522#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 20:59:00 [warn] 13525#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 20:59:00 [warn] 13528#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 20:59:00 [warn] 13528#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 18: anchored match (failed) - 2019/05/08 20:59:01 [warn] 13534#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 20:59:01 [warn] 13534#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: single capture - 2019/05/08 20:59:01 [warn] 13537#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 20:59:01 [warn] 13546#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 20:59:01 [warn] 13546#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 20:59:02 [warn] 13552#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 20:59:02 [warn] 13558#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 (dot all) - 2019/05/08 20:59:02 [warn] 13567#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 (succeeded) - 2019/05/08 20:59:02 [warn] 13573#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 20:59:03 [warn] 13579#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 20:59:03 [warn] 13582#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 20:59:10 [warn] 13721#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 20:59:20 [warn] 13871#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 2: not matched with j - 2019/05/08 20:59:28 [warn] 14015#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 20:59:28 [warn] 14015#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: just hit match limit - 2019/05/08 20:59:28 [warn] 14018#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: not matched with jo - 2019/05/08 20:59:28 [warn] 14021#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 20:59:28 [warn] 14021#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 20:59:28 [warn] 14024#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 20:59:28 [warn] 14027#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 20:59:28 [warn] 14030#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 with do - 2019/05/08 20:59:29 [warn] 14039#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 20:59:29 [warn] 14039#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 20:59:29 [warn] 14042#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 20:59:29 [warn] 14045#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: matched with d + j - 2019/05/08 20:59:29 [warn] 14048#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 20:59:30 [warn] 14057#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 20:59:30 [warn] 14057#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 20:59:39 [warn] 14228#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 20:59:46 [warn] 14252#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 55: free cleanup in ngx.timer (without sock:close) - 2019/05/08 20:59:49 [warn] 14261#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 20:59:49 [warn] 14264#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 20:59:53 [warn] 14285#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 43: bad request tries to send - 2019/05/08 20:59:54 [warn] 14297#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 20: cannot survive across request boundary (receive) - 2019/05/08 20:59:54 [warn] 14309#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 20:59:55 [warn] 14319#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 20:59:59 [warn] 14352#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 21:00:00 [warn] 14358#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 21:00:00 [warn] 14361#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 46: bad request tries to receiveuntil - 2019/05/08 21:00:01 [warn] 14364#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 41: bad request tries to connect - 2019/05/08 21:00:03 [warn] 14388#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 21:00:04 [warn] 14403#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 40: u->coctx left over bug - 2019/05/08 21:00:05 [warn] 14412#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: sanity - 2019/05/08 21:00:08 [warn] 14448#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 21:00:08 [warn] 14448#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 2: raw memcached - 2019/05/08 21:00:09 [warn] 14451#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 2: coroutine-based pub/sub - 2019/05/08 21:00:09 [warn] 14458#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: sanity - 2019/05/08 21:00:09 [warn] 14461#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 21:00:11 [warn] 14509#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 21:00:11 [warn] 14512#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 21:00:11 [warn] 14512#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 21:00:11 [warn] 14512#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 21:00:11 [warn] 14512#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 21:00:12 [warn] 14524#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: ambiguous boundary patterns (--abc) - 2019/05/08 21:00:20 [warn] 14587#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 21:00:20 [warn] 14587#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 21:00:20 [warn] 14590#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 21:00:20 [warn] 14590#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 21:00:20 [warn] 14593#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 21:00:20 [warn] 14593#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 21:00:20 [warn] 14596#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 21:00:21 [warn] 14596#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 21:00:21 [warn] 14602#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 21:00:21 [warn] 14602#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 21:00:21 [warn] 14605#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 21:00:21 [warn] 14605#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 21:00:22 [warn] 14611#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 21:00:22 [warn] 14611#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 21:00:22 [warn] 14614#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 21:00:22 [warn] 14614#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 21:00:22 [warn] 14620#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 21:00:22 [warn] 14620#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 21:00:23 [warn] 14623#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 21:00:23 [warn] 14623#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 21:00:23 [warn] 14626#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 21:00:23 [warn] 14626#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 21:00:23 [warn] 14629#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 21:00:23 [warn] 14629#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 21:00:24 [warn] 14635#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 21:00:24 [warn] 14635#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: ambiguous boundary patterns (aaa) - 2019/05/08 21:00:24 [warn] 14638#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 21:00:24 [warn] 14638#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 21:00:24 [warn] 14641#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 21:00:24 [warn] 14641#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 21:00:25 [warn] 14650#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 21:00:25 [warn] 14650#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 21:00:25 [warn] 14653#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 21:00:25 [warn] 14653#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 21:00:25 [warn] 14656#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 21:00:26 [warn] 14659#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 21:00:27 [warn] 14662#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: sanity - 2019/05/08 21:00:44 [warn] 14737#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 21:00:44 [warn] 14737#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 2: error(nil) - 2019/05/08 21:00:44 [warn] 14746#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 21:00:44 [warn] 14746#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 2: ${prefix} - 2019/05/08 21:00:45 [warn] 14752#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 1: $prefix - 2019/05/08 21:00:45 [warn] 14755#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 21:00:48 [warn] 14812#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 21:00:48 [warn] 14812#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 21:00:48 [warn] 14818#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: inclusive option value nil - 2019/05/08 21:01:03 [warn] 14939#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 21:01:03 [warn] 14939#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 21:01:03 [warn] 14942#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 21:01:03 [warn] 14942#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 21:01:03 [warn] 14945#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 21:01:03 [warn] 14945#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 21:01:03 [warn] 14948#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 21:01:03 [warn] 14948#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 21:01:04 [warn] 14951#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 21:01:04 [warn] 14951#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 21:01:04 [warn] 14954#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 21:01:04 [warn] 14954#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 21:01:04 [warn] 14957#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 21:01:04 [warn] 14957#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 3: ambiguous boundary patterns (abcabd) - inclusive mode - small buffers - 2019/05/08 21:01:04 [warn] 14960#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 21:01:04 [warn] 14960#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: bad request tries to receive - 2019/05/08 21:01:07 [warn] 15002#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 21:01:07 [warn] 15002#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 21:01:07 [warn] 15002#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 21:01:07 [warn] 15002#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 21:01:07 [warn] 15005#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: access conflicts of connect() on shared udp objects - 2019/05/08 21:01:08 [warn] 15021#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 13: bad request tries to setpeer - 2019/05/08 21:01:08 [warn] 15024#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 21:01:08 [warn] 15024#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 21:01:08 [warn] 15024#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 21:01:08 [warn] 15024#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 21:01:08 [warn] 15027#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 21:01:08 [warn] 15027#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 21:01:08 [warn] 15027#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 21:01:08 [warn] 15027#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: bad request tries to close - 2019/05/08 21:01:09 [warn] 15030#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: access conflicts of receive() on shared udp objects - 2019/05/08 21:01:10 [warn] 15048#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 21:01:10 [warn] 15048#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 21:01:10 [warn] 15048#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 21:01:10 [warn] 15048#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 1: basic coroutine print - 2019/05/08 21:01:13 [warn] 15100#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 21:01:13 [warn] 15103#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 21:01:13 [warn] 15106#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 21:01:14 [warn] 15109#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 21:01:14 [warn] 15109#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 21:01:14 [warn] 15109#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 21:01:14 [warn] 15109#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 21:01:14 [warn] 15112#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 21:01:14 [warn] 15112#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 21:01:14 [warn] 15112#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 21:01:14 [warn] 15112#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 21:01:14 [warn] 15115#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 21:01:14 [warn] 15118#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 21:01:15 [warn] 15121#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 21:01:15 [warn] 15133#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 21:01:15 [warn] 15133#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 21:01:16 [warn] 15136#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 21:01:16 [warn] 15136#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 21:01:16 [warn] 15139#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 21:01:16 [warn] 15139#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 21:01:16 [warn] 15142#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 21:01:16 [warn] 15142#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 21:01:16 [warn] 15145#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 21:01:16 [warn] 15145#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 21:01:17 [warn] 15151#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 21:01:17 [warn] 15154#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 21:01:17 [warn] 15163#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 21:01:18 [warn] 15166#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 21:01:18 [warn] 15169#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 21:01:18 [warn] 15172#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 21:01:18 [warn] 15175#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 21:01:18 [warn] 15178#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: user threads + ngx.socket.tcp - 2019/05/08 21:01:19 [warn] 15184#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 21:01:19 [warn] 15187#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 21:01:19 [warn] 15187#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 6: nested user threads - 2019/05/08 21:01:19 [warn] 15190#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 21:01:19 [warn] 15190#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: manual time slicing between two user threads - 2019/05/08 21:01:19 [warn] 15193#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 21:01:19 [warn] 15193#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 21:01:19 [warn] 15196#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 21:01:20 [warn] 15203#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 21:01:20 [warn] 15203#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 21:01:20 [warn] 15206#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 without I/O - 2019/05/08 21:01:20 [warn] 15209#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 21:01:20 [warn] 15212#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: entry thread and a user thread flushing at the same time - 2019/05/08 21:01:21 [warn] 15215#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 21:01:21 [warn] 15218#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 21:01:21 [warn] 15218#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 12: manual time slicing between a user thread and the entry thread - 2019/05/08 21:01:22 [warn] 15221#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: simple user thread without I/O - 2019/05/08 21:01:22 [warn] 15224#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 21:01:22 [warn] 15227#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 21:01:22 [warn] 15230#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 21:01:23 [warn] 15233#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 21:01:23 [warn] 15236#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 21:01:23 [warn] 15236#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 21:01:23 [warn] 15239#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 21:01:23 [warn] 15239#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: two user threads flushing at the same time - 2019/05/08 21:01:24 [warn] 15242#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 21:01:24 [warn] 15242#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: simple user thread with ngx.req.socket() - 2019/05/08 21:01:24 [warn] 15245#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 21:01:24 [warn] 15251#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 21:01:24 [warn] 15251#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: exit in user thread (entry thread is still pending on ngx.sleep) - 2019/05/08 21:01:24 [warn] 15254#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 21:01:25 [warn] 15257#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: exit in user thread (entry thread is still pending on tcpsock:receive) - 2019/05/08 21:01:25 [warn] 15260#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 21:01:26 [warn] 15263#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 21:01:26 [warn] 15266#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 21:01:26 [warn] 15269#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 21:01:26 [alert] 15269#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 4: exit in user thread (entry already quits) - 2019/05/08 21:01:27 [warn] 15272#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 21:01:27 [warn] 15275#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: exit in user thread (entry thread is still pending on tcpsock:connect) - 2019/05/08 21:01:28 [warn] 15278#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 21:01:28 [warn] 15281#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 21:01:28 [alert] 15281#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 11: waiting on two simple user threads without I/O - 2019/05/08 21:01:29 [warn] 15287#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 21:01:29 [warn] 15287#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 21:01:29 [warn] 15290#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 21:01:29 [warn] 15290#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 21:01:29 [warn] 15290#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 21:01:29 [warn] 15290#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 8: simple user thread wait with I/O, throw errors - 2019/05/08 21:01:29 [warn] 15293#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 21:01:30 [warn] 15296#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 21:01:30 [warn] 15299#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 21:01:30 [warn] 15302#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 21:01:30 [warn] 15302#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: lua backtrace dumper may access dead parent coroutines - 2019/05/08 21:01:30 [warn] 15305#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 21:01:31 [warn] 15308#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 21:01:31 [warn] 15308#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 21:01:31 [warn] 15308#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 21:01:31 [warn] 15308#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 7: simple user thread wait without I/O, throw errors - 2019/05/08 21:01:32 [warn] 15311#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 21:01:32 [warn] 15314#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 21:01:32 [warn] 15314#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 21:01:32 [warn] 15317#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 21:01:32 [warn] 15317#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: simple user thread wait with I/O - 2019/05/08 21:01:33 [warn] 15320#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 21: waiting on a dead coroutine - 2019/05/08 21:01:33 [warn] 15323#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 21:01:33 [warn] 15326#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 21:01:33 [warn] 15326#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 22: spawn and wait uthreads for many times - 2019/05/08 21:01:34 [warn] 15329#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 21:01:35 [warn] 15332#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 21:01:35 [warn] 15332#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 21:01:35 [warn] 15332#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 21:01:35 [warn] 15332#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 15: waiting on two simple user threads with I/O, both aborted by errors - 2019/05/08 21:01:35 [warn] 15335#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 21:01:35 [warn] 15335#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 21:01:36 [warn] 15338#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 21:01:36 [warn] 15338#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 21:01:36 [warn] 15341#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 21:01:36 [warn] 15341#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 21:01:37 [warn] 15347#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 21:01:37 [warn] 15347#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 6: simple user thread wait with I/O, return multiple values - 2019/05/08 21:01:37 [warn] 15350#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: simple user thread wait without I/O (return multiple values) - 2019/05/08 21:01:38 [warn] 15353#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: cosocket + stop - 2019/05/08 21:01:47 [warn] 15389#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 12: ngx.thread API - 2019/05/08 21:02:13 [warn] 15455#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 21:02:18 [warn] 15482#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 2: separated global env - 2019/05/08 21:02:22 [warn] 15503#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 10: ngx.thread API - 2019/05/08 21:02:32 [warn] 15567#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 21:02:36 [warn] 15588#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 21:03:09 [warn] 15862#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 21:03:10 [warn] 15883#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 21:03:20 [warn] 16062#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 21:03:20 [warn] 16062#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 1: kill pending sleep - 2019/05/08 21:03:21 [warn] 16086#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 21:03:21 [warn] 16089#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 21:03:21 [alert] 16089#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 3: kill pending resolver - 2019/05/08 21:03:22 [alert] 16089#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 4: kill pending connect - 2019/05/08 21:03:22 [warn] 16092#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 21:03:22 [warn] 16095#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: kill a thread already terminated - 2019/05/08 21:03:22 [warn] 16098#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: already waited - 2019/05/08 21:03:23 [warn] 16101#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 21:03:26 [alert] 16129#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
TEST 6: concurrent operations while resolving - 2019/05/08 21:03:27 [alert] 16129#0: send() failed (1: Operation not permitted) while resolving, resolver: 127.0.0.2:12345
killing the child process 16133 with force... at /home/ec2-user/git/stream-lua-nginx-module/../test-nginx/lib/Test/Nginx/Util.pm line 608.
killing the child process 16134 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 21:03:52 [crit] 16222#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 21:03:52 [crit] 16222#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 21:04:02 [warn] 16296#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 21:04:12 [warn] 16441#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 21:04:21 [warn] 16502#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 8: balancer_by_lua - 2019/05/08 21:04:22 [warn] 16520#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 21:04:22 [crit] 16520#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 21:04:22 [crit] 16520#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 21:04:22 [warn] 16523#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: preread_by_lua - 2019/05/08 21:04:23 [warn] 16526#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 21:04:23 [warn] 16532#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 6: timer - 2019/05/08 21:04:23 [warn] 16538#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 9: warn messages for polluting _G table when handling request - 2019/05/08 21:04:24 [warn] 16541#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 21:04:24 [warn] 16541#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 4: content_by_lua - 2019/05/08 21:04:24 [warn] 16544#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.