• Status New
  • Percent Complete
    0%
  • Task Type Bug Report
  • Category Packages → Packages: Build-list
  • Assigned To No-one
  • Operating System
  • Severity Low
  • Priority Medium
  • Reported Version
  • Due in Version Undecided
  • Due Date Undecided
  • Votes
  • Private
Attached to Project: Archlinux32
Opened by Erich Eckner - 18.02.2018

FS#29 - [haskell-hslua] check() fails

several failures during check() - disabling for now

==> Starting check()...
Running 1 test suites...
Test suite test-hslua: RUNNING...
hslua

Haskell version of the C API
  copy
    copies stack elements using positive indices:               OK
    copies stack elements using negative indices:               OK
  insert
    inserts stack elements using negative indices:              OK
    inserts stack elements using negative indices:              OK
  absindex:                                                     OK
  gettable gets a table value:                                  FAIL
    test/Test/HsLua/Util.hs:35:
    lua operation returned false
  strlen, objlen, and rawlen all behave the same:               OK
  Type checking
    isfunction:                                                 OK
    isnil:                                                      OK
    isnone:                                                     OK
    isnoneornil:                                                OK
  CFunction handling:                                           OK
  getting values
    tointegerx returns numbers verbatim:                        OK
    tointegerx accepts strings coercible to integers:           OK
    tointegerx returns Nothing when given a boolean:            OK
    tonumberx returns numbers verbatim:                         OK
    tonumberx accepts strings as numbers:                       OK
    tonumberx returns Nothing when given a boolean:             OK
  setting and getting a global works:                           OK
  can push and receive a thread:                                OK
  different threads are not equal:                              OK
  thread status:                                                OK
  loading
    loadstring status:                                          OK
    dostring loading:                                           OK
    dofile loading:                                             OK
  pcall status:                                                 OK
  garbage collection:                                           OK
  compare
    identifies strictly smaller values:                         FAIL
      *** Failed! Assertion failed (after 1 test): 
      LuaInteger 0
      Use --quickcheck-replay=586817 to reproduce.
    identifies smaller or equal values:                         FAIL
      *** Failed! Assertion failed (after 1 test): 
      LuaInteger 0
      Use --quickcheck-replay=316579 to reproduce.
    identifies equal values:                                    OK
      +++ OK, passed 100 tests.
  lessthan works:                                               FAIL
    *** Failed! Assertion failed (after 2 tests): 
    LuaNumber (-0.35170612)
    LuaNumber 0.84471506
    Use --quickcheck-replay=507888 to reproduce.
  order of Lua types is consistent:                             OK
    +++ OK, passed 100 tests.
  functions can throw a table as error message:                 OK
  handling table errors won't leak:                             OK
Interoperability
  call haskell functions from lua
    push haskell function to lua:                               OK
    push multi-argument haskell function to lua:                OK
    argument type errors are propagated:                        OK
    convert haskell function to c function:                     OK
    Error in Haskell function is converted into Lua error:      OK
  call lua function from haskell
    test equality within lua:                                   FAIL
      test/Foreign/Lua/FunctionCallingTest.hs:106:
      raw equality test failed
      expected: True
       but got: False
    failing lua function call:                                  OK
    print the empty string via lua procedure:                   

OK

    failing lua procedure call:                                 OK
Utilities
  Optional return the value if it exists:                       OK
  Optional can deal with missing values:                        OK
  raiseError causes a Lua error:                                OK
Sendings and receiving values from the stack
  peek and push are well behaved
    Peek can act as left inverse of push
      round-tripping unit:                                      OK
        +++ OK, passed 100 tests.
      booleans remain equal under push/peek:                    OK
        +++ OK, passed 100 tests.
      lua numbers (i.e., doubles) remain equal under push/peek: FAIL
        *** Failed! Assertion failed (after 2 tests): 
        LuaNumber (-1.926296)
        Use --quickcheck-replay=670723 to reproduce.
      lua integers remain equal under push/peek:                IGNORED
      bytestring remain equal under push/peek:                  OK
        +++ OK, passed 100 tests.
      round-tripping strings:                                   OK (0.01s)
        +++ OK, passed 100 tests.
      lists of boolean remain equal under push/peeks:           OK
        +++ OK, passed 100 tests.
      lists of lua integers remain equal under push/peek:       IGNORED
      lists of bytestrings remain equal under push/peek:        OK (0.15s)
        +++ OK, passed 100 tests.
      text:                                                     OK
        +++ OK, passed 100 tests.
      map of strings to LuaNumber:                              FAIL
        *** Failed! Assertion failed (after 2 tests and 1 shrink): 
        fromList [("",LuaNumber (-0.9010369))]
        Use --quickcheck-replay=119067 to reproduce.
      tuples
        pair of LuaNumbers:                                     FAIL
          *** Failed! Assertion failed (after 2 tests): 
          (LuaNumber (-0.34098855),LuaNumber 0.2441068)
          Use --quickcheck-replay=296075 to reproduce.
        triple of LuaNumbers:                                   FAIL
          *** Failed! Assertion failed (after 2 tests): 
          (LuaNumber 0.46677026,LuaNumber 0.9009714,LuaNumber 0.2326173)
          Use --quickcheck-replay=85608 to reproduce.
        quadruple of LuaNumbers:                                FAIL
          *** Failed! Assertion failed (after 2 tests): 
          (LuaNumber 1.8909019,LuaNumber (-0.85486156),LuaNumber (-4.0685906),LuaNumber (-12.583851))
          Use --quickcheck-replay=305430 to reproduce.
        quintuple of LuaNumbers:                                FAIL
          *** Failed! Assertion failed (after 2 tests): 
          (LuaNumber 0.2735047,LuaNumber 2.1247218,LuaNumber 0.1806469,LuaNumber 0.9455812,LuaNumber 0.98733383)
          Use --quickcheck-replay=608867 to reproduce.
        hextuple of Text, LuaNumbers and Booleans:              FAIL
          *** Failed! Assertion failed (after 2 tests and 1 shrink): 
          (False,LuaNumber (-2.381176),"",False,LuaNumber (-0.8418731),LuaNumber (-0.39977068))
          Use --quickcheck-replay=572229 to reproduce.
        septuple of Text, LuaNumber and Booleans:               FAIL
          *** Failed! Assertion failed (after 2 tests and 3 shrinks): 
          ("",False,LuaNumber 1.3463217,False,False,LuaNumber (-1.4167022),False)
          Use --quickcheck-replay=692263 to reproduce.
        octuple of Strings and Booleans:                        OK (0.03s)
          +++ OK, passed 100 tests.
    Random stack values
      can push/pop booleans:                                    OK (0.01s)
        +++ OK, passed 100 tests.
      can push/pop lua integers:                                OK (0.01s)
        +++ OK, passed 100 tests.
      can push/pop lua numbers:                                 FAIL
        *** Failed! Assertion failed (after 3 tests): 
        LuaNumber 1.5588847
        Ordered {getOrdered = [Positive {getPositive = LuaInteger 1},Positive {getPositive = LuaInteger 2}]}
        Use --quickcheck-replay=197445 to reproduce.
      can push/pop bytestrings:                                 OK (0.02s)
        +++ OK, passed 100 tests.
      can push/pop lists of booleans:                           OK (0.04s)
        +++ OK, passed 100 tests.
      can push/pop lists of LuaIntegers:                        OK (0.04s)
        +++ OK, passed 100 tests.
      can push/pop lists of bytestrings:                        OK (0.19s)
        +++ OK, passed 100 tests.
  FromLuaStack
    receives basic values from the stack:                       OK
    returns an error if the types don't match:                  OK
    list cannot be read if a list element fails:                OK
    stack is unchanged if getting a list fails:                 OK
    stack is unchanged if getting key-value pairs fails:        OK
  ToLuaStack
    pushing simple values to the stack
      Boolean can be pushed correctly:                          OK
      LuaNumbers can be pushed correctly:                       FAIL
        test/Foreign/Lua/Types/ToLuaStackTest.hs:105:
        5::LuaNumber was not pushed
      LuaIntegers can be pushed correctly:                      FAIL
        test/Foreign/Lua/Types/ToLuaStackTest.hs:105:
        42::LuaInteger was not pushed
      ByteStrings can be pushed correctly:                      OK
      Unit is pushed as nil:                                    OK
      Pointer is pushed as light userdata:                      OK
    pushing a value increases stack size by one
      LuaInteger:                                               OK
        +++ OK, passed 100 tests.
      LuaNumber:                                                OK
        +++ OK, passed 100 tests.
      ByteString:                                               OK
        +++ OK, passed 100 tests.
      String:                                                   OK
        +++ OK, passed 100 tests.
      list of booleans:                                         OK
        +++ OK, passed 100 tests.
lua integration tests
  print version:                                                OK
  functions stored in / retrieved from registry:                OK
  getting a nested global works:                                OK
  setting a nested global works:                                OK
  table reading:                                                OK
  Getting strings to and from the stack
    unicode ByteString:                                         OK
    ByteString should survive after GC/Lua destroyed:           OK
    String with NUL byte should be pushed/popped correctly:     OK
  luaopen_* functions
    opendebug:                                                  OK
    openio:                                                     OK
    openmath:                                                   OK
    openos:                                                     OK
    openpackage:                                                OK
    openstring:                                                 OK
    opentable:                                                  OK
  luaopen_base returns the right number of tables
    openbase:                                                   OK
  C functions
    Registering a C function and calling it from Lua:           FAIL
      test/Foreign/LuaTest.hs:162:
      greeting function failed
      expected: Right ["Caffeine","induced","nonsense"]
       but got: Right []
    pushing a C closure to and calling it from Lua:             OK
  error handling
    lua errors are caught:                                      OK
    error-less code gives in 'Right' result:                    OK
    catching lua errors within the lua type:                    OK
    second alternative is used when first fails:                OK
    Applicative.empty implementation throws an exception:       OK
    catching error of a failing meta method:                    OK
    calling a function that errors throws exception:            OK

17 out of 112 tests failed (0.60s)
Test suite test-hslua: FAIL
Test suite logged to: dist/test/hslua-0.9.5-test-hslua.log
0 of 1 test suites (0 of 1 test cases) passed.
==> ERROR: A failure occurred in check().

Loading...

Available keyboard shortcuts

Tasklist

Task Details

Task Editing