Error reporting revamp

* set_error_reporting() is gone
* new lane generator setting error_reporting_level
* basic/extended stack trace is selectable at runtime instead of compile-time

1 files changed, 224 insertions, 40 deletions

diff --git a/tests/error.lua b/tests/error.lua
index 91ccebc..126161e 100644
--- a/tests/error.lua
+++ b/tests/error.lua
@@ -1,58 +1,242 @@
 --

 -- Error reporting

 --

--- Note: this code is supposed to end in errors; not included in 'make test'

---

+local which_tests, remaining_tests = {}, {}

+for k,v in ipairs{...} do

+    print("got arg:", type(v), tostring(v))

+    which_tests[v] = true

+    remaining_tests[v] = true

+end

+

+--##################################################################################################

+

+local lanes = require "lanes".configure{with_timers = false}

+local null = lanes.null

+

+--##################################################################################################

+

+-- Lua51 support

+local table_unpack = unpack or table.unpack

 

-local lanes = require "lanes".configure{ with_timers = false}

+--##################################################################################################

 

-local function lane( mode_)

-    set_error_reporting( mode_)

-    local subf= function()  -- this so that we can see the call stack

-        error "aa"

-        --error({})

-        --error(error)

+local WR = function(...)

+    local str=""

+    for i=1,select('#',...) do

+        local v = select(i,...)

+        if type(v) == "function" then

+            local infos = debug.getinfo(v)

+            --[[for k,v in pairs(infos) do

+                print(k,v)

+            end]]

+            v = infos.source..":"..infos.linedefined

+        end

+        str= str..tostring(v).."\t"

     end

-    local subf2= function()

-        subf()

+    if io then

+        io.stderr:write(str.."\n")

     end

-    subf2()

 end

 

-local function cleanup(err)

+--##################################################################################################

+

+local lane_body = function(error_value_, finalizer_, finalizer_error_value_)

+    WR( "In Lane body: EV: ", error_value_, " F: ", finalizer_, " FEV: ", finalizer_error_value_)

+    if finalizer_ then

+        local finalizer = function(err_, stack_)

+            finalizer_(err_, stack_)

+            if finalizer_error_value_ then

+                WR ("Finalizer raises ", finalizer_error_value_)

+                error(finalizer_error_value_, 0) -- 0 so that error() doesn't alter the error value

+            end

+        end

+        set_finalizer(finalizer)

+    end

+

+    local subf = function()  -- this so that we can see the call stack

+        if error_value_ then

+            error(error_value_, 0) -- 0 so that error() doesn't alter the error value

+        end

+        return "success"

+    end

+    local subf2 = function(b_)

+        return b_ or subf() -- prevent tail call

+    end

+    local subf3 = function(b_)

+        return b_ or subf2() -- prevent tail call

+    end

+    return subf3(false)

 end

 

-local lgen = lanes.gen("*", { --[[finalizer=cleanup]] }, lane)

+--##################################################################################################

 

----

-io.stderr:write( "\n** Error catching **\n" )

---

+local lane_finalizer = function(err_, stack_)

+    WR("In finalizer: ", err_, stack_)

+end

 

-local error_reporting_mode = "extended"

-local h= lgen( error_reporting_mode)

-local _,err,stack= h:join()   -- wait for the lane (no automatic error propagation)

+--##################################################################################################

+

+local start_lane = function(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

+    return lanes.gen("*", {error_trace_level = error_reporting_mode_}, lane_body)(error_value_, finalizer_, finalizer_error_value_)

+end

 

-if err then

-    assert( type(stack)=="table" ) -- only true if lanes was compiled with ERROR_FULL_STACK == 1

-    io.stderr:write( "Lane error: "..tostring(err).."\n" )

+--##################################################################################################

+--##################################################################################################

 

-        if error_reporting_mode == "basic" then -- each stack line is a string in basic mode

-                io.stderr:write( "\t", table.concat(stack,"\n\t"), "\n" );

-        else -- each stack line is a table in extended mode

-                for line, details in pairs( stack) do

-                        io.stderr:write( "\t", tostring( line), "\n" );

-                        for detail, value in pairs( details) do

-                                io.stderr:write( "\t\t", tostring( detail), ":", tostring( value), "\n")

-                        end

-                end

-        end

+local make_table_error_mt = function()

+    return {

+        __tostring = function() return "{error as table}" end,

+        __eq = function(t1_, t2_)

+            -- because tables transfered through linda/error reporting are identical, but not equal

+            -- however, due to metatable caching by Lanes, their metatables should be the same

+            return getmetatable(t1_) == getmetatable(t2_)

+        end

+    }

 end

 

----

-io.stderr:write( "\n** Error propagation **\n" )

---

-local h2= lgen( error_reporting_mode)

-local _= h2[0]

-assert(false)   -- does NOT get here

+local lane_error_as_string = "'lane error as string'"

+local lane_error_as_table = setmetatable({}, make_table_error_mt())

+local lane_error_as_linda = lanes.linda("'lane error'")

+

+local finalizer_error_as_string = "'lane error as string'"

+local finalizer_error_as_table = setmetatable({}, make_table_error_mt())

+local finalizer_error_as_linda = lanes.linda("'lane error'")

+

+local test_settings = {}

+local configure_tests = function()

+    local append_test = function(level, lane_error, finalizer, finalizer_error)

+        -- convert back null to nil

+        lane_error = lane_error ~= null and lane_error or nil

+        finalizer = finalizer ~= null and finalizer or nil

+        finalizer_error = finalizer_error ~= null and finalizer_error or nil

+        -- compose test description string

+        local test_header = table.concat({

+            level .. " error reporting",

+            (lane_error and tostring(lane_error) or "no error") .. " in lane",

+            (finalizer and "with" or "without").. " finalizer" .. ((finalizer and finalizer_error) and " raising " .. tostring(finalizer_error) or "")

+        }, ", ")

+        print(test_header)

+        test_settings[test_header] = { level, lane_error, finalizer, finalizer_error }

+    end

+    -- can't store nil in tables, use null instead

+    local levels = {

+        "minimal",

+        "basic",

+        "extended",

+    }

+    local errors = {

+        null,

+        lane_error_as_string,

+        lane_error_as_table,

+        lane_error_as_linda,

+    }

+    local finalizers = {

+        null,

+        lane_finalizer,

+    }

+    local finalizer_errors = {

+        null,

+        finalizer_error_as_string,

+        finalizer_error_as_table,

+        finalizer_error_as_linda,

+    }

+ 

+    for _, level in ipairs(levels) do

+        for _, lane_error in ipairs(errors) do

+            for _, finalizer in ipairs(finalizers) do

+                for _, finalizer_error in ipairs(finalizer_errors) do

+                    append_test(level, lane_error, finalizer, finalizer_error)

+                end

+            end

+        end

+    end

+end

+

+configure_tests()

+-- do return end

+

+--##################################################################################################

+--##################################################################################################

+

+local do_error_catching_test = function(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

+    local h = start_lane(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

+    local ret,err,stack= h:join()   -- wait for the lane (no automatic error propagation)

+    WR("Processing results for {", error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_, "}")

+    if err then

+        assert(ret == nil)

+        assert(error_reporting_mode_ == "minimal" or type(stack)=="table") -- only true if lane was configured with error_trace_level ~= "minimal"

+        if err == error_value_ then

+            WR("Lane regular error: ", err)

+        elseif err == finalizer_error_value_ then

+            WR("Lane finalizer error: ", err)

+        else

+            WR("Unknown error: ", type(err), err)

+            assert(false)

+        end

+        if error_reporting_mode_ == "minimal" then

+            assert(stack == nil, table.concat{"stack is a ", type(stack)})

+        elseif error_reporting_mode_ == "basic" then -- each stack line is a string in basic mode

+            WR("STACK:\n", table.concat(stack,"\n\t"));

+        else -- each stack line is a table in extended mode

+            WR "STACK:"

+            for line, details in pairs(stack) do

+                WR("\t", line);

+                for detail, value in pairs(details) do

+                    WR("\t\t", detail, ": ", value)

+                end

+            end

+        end

+    else -- no error

+        assert(ret == "success")

+        WR("No error in lane: ", ret)

+    end

+    WR "TEST OK"

+end

+

+--##################################################################################################

+

+local do_error_propagation_test = function(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

+    local wrapper = function()

+        local raises_error = (error_value_ or finalizer_error_value_) and true or false

+        local h = start_lane(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

+        local _ = h[0]

+        -- if the lane is configured to raise an error, we should not get here

+        assert(not raises_error, "should not get here")

+    end

+    local err, msg = pcall(wrapper)

+    WR("Processing results for {", error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_, "}")

+    if err then

+        WR("Lane error: ", msg)

+    end

+    WR "TEST OK"

+end

+

+--##################################################################################################

+

+local perform_test = function(title_, test_)

+    WR "###########################################################################"

+    WR ("** " .. title_ .. " **")

+    for desc, settings in pairs(test_settings) do

+        WR "---------------------------------------------------------------------------"

+        WR(desc)

+        test_(table_unpack(settings))

+    end

+end

+

+if not next(which_tests) or which_tests.catch then

+    remaining_tests.catch = nil

+    perform_test("Error catching", do_error_catching_test)

+end

+

+--##################################################################################################

+if not next(which_tests) or which_tests.propagate then

+    remaining_tests.propagate = nil

+    perform_test("Error propagation", do_error_propagation_test)

+end

+

+-- ##################################################################################################

+

+local unknown_test, val = next(remaining_tests)

+assert(not unknown_test, tostring(unknown_test) .. " test is unknown")

 

---never ends

+print "\nTHE END"