# 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$'