# General Lua Libraries for Lua 5.1, 5.2 & 5.3

# Copyright (C) 2011-2018 stdlib authors

before: |

base_module = 'debug'

this_module = 'std.debug'

global_table = '_G'

extend_base = {'getfenv', 'setfenv', 'say', 'trace'}

M = require(this_module)

specify std.debug:

- context when required:

- context by name:

- it does not touch the global table:

expect(show_apis {added_to=global_table, by=this_module}).

to_equal {}

- it does not touch the core debug table:

expect(show_apis {added_to=base_module, by=this_module}).

to_equal {}

- it contains apis from the core debug table:

expect(show_apis {from=base_module, not_in=this_module}).

to_contain.a_permutation_of(extend_base)

- context via the std module:

- it does not touch the global table:

expect(show_apis {added_to=global_table, by='std'}).

to_equal {}

- it does not touch the core debug table:

expect(show_apis {added_to=base_module, by='std'}).

to_equal {}

- describe debug:

- it does nothing when std._debug is disabled:

expect(luaproc [[

require 'std._debug'(false)

require 'std.debug'('nothing to see here')

]]).not_to_contain_error 'nothing to see here'

- it writes to stderr when std._debug is not set:

expect(luaproc [[

require 'std.debug'('debugging')

]]).to_contain_error 'debugging'

- it writes to stderr when std._debug is enabled:

expect(luaproc [[

require 'std._debug'(true)

require 'std.debug'('debugging')

]]).to_contain_error 'debugging'

- it writes to stderr when std._debug.level is not set:

expect(luaproc [[

require 'std._debug'()

require 'std.debug'('debugging')

]]).to_contain_error 'debugging'

- it writes to stderr when std._debug.level is specified:

expect(luaproc [[

require 'std._debug'.level = 0

require 'std.debug'('debugging')

]]).to_contain_error 'debugging'

expect(luaproc [[

require 'std._debug'.level = 1

require 'std.debug'('debugging')

]]).to_contain_error 'debugging'

expect(luaproc [[

require 'std._debug'.level = 2

require 'std.debug'('debugging')

]]).to_contain_error 'debugging'

- describe say:

- it uses normalize.str:

expect(luaproc [[require 'std.debug'.say {'debugging'}]]).

to_contain_error(require 'std.normalize'.str {'debugging'})

- context when std._debug is disabled:

- before:

preamble = [[

require 'std._debug'(false)

]]

- it does nothing when message level is not set:

expect(luaproc(preamble .. [[

require 'std.debug'.say 'nothing to see here'

]])).not_to_contain_error 'nothing to see here'

- it does nothing when message is set:

for _, level in next, {-999, 0, 1, 2, 999} do

expect(luaproc(preamble .. [[

require 'std.debug'.say(]] .. level .. [[, 'nothing to see here')

]])).not_to_contain_error 'nothing to see here'

end

- context when std._debug is not set:

- it writes to stderr when message level is not set:

expect(luaproc [[

require 'std.debug'.say 'debugging'

]]).to_contain_error 'debugging'

- it writes to stderr when message level is 1 or lower:

for _, level in next, {-999, 0, 1} do

expect(luaproc([[

require 'std.debug'.say(]] .. level .. [[, 'debugging')

]])).to_contain_error 'debugging'

end

- it does nothing when message level is 2 or higher:

for _, level in next, {2, 999} do

expect(luaproc([[

require 'std.debug'.say(]] .. level .. [[, 'nothing to see here')

]])).not_to_contain_error 'nothing to see here'

end

- context when std._debug is enabled:

- before:

preamble = [[

require 'std._debug'(true)

]]

- it writes to stderr when message level is not set:

expect(luaproc(preamble .. [[

require 'std.debug'.say 'debugging'

]])).to_contain_error 'debugging'

- it writes to stderr when message level is 1 or lower:

for _, level in next, {-999, 0, 1} do

expect(luaproc(preamble .. [[

require 'std.debug'.say(]] .. level .. [[, 'debugging')

]])).to_contain_error 'debugging'

end

- it does nothing when message level is 2 or higher:

for _, level in next, {2, 999} do

expect(luaproc(preamble .. [[

require 'std.debug'.say(]] .. level .. [[, 'nothing to see here')

]])).not_to_contain_error 'nothing to see here'

end

- context when std._debug.level is not set:

- it writes to stderr when message level is not set:

expect(luaproc [[

require 'std.debug'.say 'debugging'

]]).to_contain_error 'debugging'

- it writes to stderr when message level is 1 or lower:

for _, level in next, {-999, 0, 1} do

expect(luaproc([[

require 'std.debug'.say(]] .. level .. [[, 'debugging')

]])).to_contain_error 'debugging'

end

- it does nothing when message level is 2 or higher:

for _, level in next, {2, 999} do

expect(luaproc([[

require 'std.debug'.say(]] .. level .. [[, 'nothing to see here')

]])).not_to_contain_error 'nothing to see here'

end

- context when std._debug.level is specified:

- it writes to stderr when message level is 1 or lower:

for _, level in next, {0, 1, 2} do

expect(luaproc([[

require 'std._debug'.level = ]] .. level .. [[

require 'std.debug'.say 'debugging'

]])).to_contain_error 'debugging'

end

- it does nothing when message level is higher than debug level:

expect(luaproc [[

require 'std._debug'.level = 2

require 'std.debug'.say(3, 'nothing to see here')

]]).not_to_contain_error 'nothing to see here'

- it writes to stderr when message level equals debug level:

expect(luaproc [[

require 'std._debug'.level = 2

require 'std.debug'.say(2, 'debugging')

]]).to_contain_error 'debugging'

- it writes to stderr when message level is lower than debug level:

expect(luaproc [[

require 'std._debug'.level = 2

require 'std.debug'.say(1, 'debugging')

]]).to_contain_error 'debugging'

- describe trace:

- before:

f = init(M, this_module, 'trace')

- it does nothing when debug hint is disabled:

expect(luaproc [[

require 'std._debug'(false)

require 'std.debug'

os.exit(0)

]]).to_succeed_with ''

- it does nothing when debug hint is not set:

expect(luaproc [[

require 'std.debug'

os.exit(0)

]]).to_succeed_with ''

- it does nothing when debug hint is enabled:

expect(luaproc [[

require 'std._debug'(true)

require 'std.debug'

os.exit(0)

]]).to_succeed_with ''

- it enables automatically when std._debug.call is set: |

expect(luaproc [[

require 'std._debug'.call = true

require 'std.debug'

os.exit(1)

]]).to_fail_while_containing ':3 call exit'

- it is enabled manually with debug.sethook: |

expect(luaproc [[

local debug = require 'std.debug'

debug.sethook(debug.trace, 'cr')

os.exit(1)

]]).to_fail_while_containing ':3 call exit'

- it writes call trace log to standard error: |

expect(luaproc [[

local debug = require 'std.debug'

debug.sethook(debug.trace, 'cr')

os.exit(0)

]]).to_contain_error ':3 call exit'

- it traces lua calls: |

expect(luaproc [[

local debug = require 'std.debug' -- line 1

local function incr(i) return i + 1 end -- line 2

debug.sethook(debug.trace, 'cr') -- line 3

os.exit(incr(41)) -- line 4

]]).to_fail_while_matching '.*:4 call incr <2:.*:4 return incr <2:.*'

- it traces C api calls: |

expect(luaproc [[

local debug = require 'std.debug'

local function incr(i) return i + 1 end

debug.sethook(debug.trace, 'cr')

os.exit(incr(41))

]]).to_fail_while_matching '.*:4 call exit %[C%]%s$'