Subject: bug#33845: test of hslua fail on i686

From: [email-masked]
Date: Sun, 23 Dec 2018 01:20:14 -0800

This is a dep of pandoc.

sdb@antelope ~/Desktop$ guix --version
guix (GNU Guix) 0.16.0-5.5de5f81

installed from git on 
sdb@antelope ~$ cd ~/src/guix && git log |head -1
commit d15211c9b5b46b96c5b658329624942b6ff5c917

starting phase `check'
running "runhaskell Setup.hs" with command "test" and parameters ()
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:                                  OK
    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:                           FAIL
      test/Test/HsLua/Util.hs:35:
      lua operation returned false
    can push and receive a thread:                                OK
    different threads are not equal:                              OK
    thread status:                                                OK
    loading
      loadstring status:                                          OK
      dostring loading:                                           OK
      loadfile loading:                                           OK
      dofile loading:                                             OK
    pcall status:                                                 OK
    garbage collection:                                           OK
    compare
      identifies strictly smaller values:                         OK
(0.01s)
        +++ OK, passed 100 tests.
      identifies smaller or equal values:                         OK
        +++ OK, passed 100 tests.
      identifies equal values:                                    OK
(0.02s)
        +++ OK, passed 100 tests.
    lessthan works:                                               OK
      +++ OK, passed 100 tests.
    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:                                   OK
      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: OK
          +++ OK, passed 100 tests.
        lua integers remain equal under push/peek:               
IGNORED
        bytestring remain equal under push/peek:                  OK
(0.02s)
          +++ OK, passed 100 tests.
        round-tripping strings:                                   OK
(0.04s)
          +++ OK, passed 100 tests.
        lists of boolean remain equal under push/peeks:           FAIL
          *** Failed! Assertion failed (after 3 tests):
          [False]
          Use --quickcheck-replay=707636 to reproduce.
        lists of lua integers remain equal under push/peek:      
IGNORED
        lists of bytestrings remain equal under push/peek:        OK
(0.40s)
          +++ OK, passed 100 tests.
        text:                                                     OK
          +++ OK, passed 100 tests.
        map of strings to LuaNumber:                              OK
(0.38s)
          +++ OK, passed 100 tests.
        tuples
          pair of LuaNumbers:                                     OK
            +++ OK, passed 100 tests.
          triple of LuaNumbers:                                   OK
            +++ OK, passed 100 tests.
          quadruple of LuaNumbers:                                OK
            +++ OK, passed 100 tests.
          quintuple of LuaNumbers:                                OK
            +++ OK, passed 100 tests.
          hextuple of Text, LuaNumbers and Booleans:              OK
(0.02s)
            +++ OK, passed 100 tests.
          septuple of Text, LuaNumber and Booleans:               OK
(0.01s)
            +++ OK, passed 100 tests.
          octuple of Strings and Booleans:                        OK
(0.02s)
            +++ OK, passed 100 tests.
      Random stack values
        can push/pop booleans:                                    OK
          +++ OK, passed 100 tests.
        can push/pop lua integers:                                OK
          +++ OK, passed 100 tests.
        can push/pop lua numbers:                                 OK
(0.01s)
          +++ OK, passed 100 tests.
        can push/pop bytestrings:                                 OK
(0.02s)
          +++ OK, passed 100 tests.
        can push/pop lists of booleans:                           FAIL
          *** Failed! Assertion failed (after 54 tests and 5 shrinks):
          [False]
          Ordered {getOrdered = [Positive {getPositive = LuaInteger
3},Positive {getPositive = LuaInteger 3},Positive {getPositive =
LuaInteger 4},Positive {getPositive = LuaInteger 5},Positive
{getPositive = LuaInteger 5},Positive {getPositive = LuaInteger
6},Positive {getPositive = LuaInteger 6},Positive {getPositive =
LuaInteger 8},Positive {getPositive = LuaInteger 10},Positive
{getPositive = LuaInteger 10},Positive {getPositive = LuaInteger
11},Positive {getPositive = LuaInteger 11},Positive {getPositive =
LuaInteger 11},Positive {getPositive = LuaInteger 12},Positive
{getPositive = LuaInteger 12},Positive {getPositive = LuaInteger
13},Positive {getPositive = LuaInteger 13},Positive {getPositive =
LuaInteger 13},Positive {getPositive = LuaInteger 14},Positive
{getPositive = LuaInteger 15},Positive {getPositive = LuaInteger
17},Positive {getPositive = LuaInteger 18},Positive {getPositive =
LuaInteger 18},Positive {getPositive = LuaInteger 21},Positive
{getPositive = LuaInteger 23},Positive {getPositive = LuaInteger
24},Positive {getPositive = LuaInteger 25},Positive {getPositive =
LuaInteger 27},Positive {getPositive = LuaInteger 28},Positive
{getPositive = LuaInteger 29},Positive {getPositive = LuaInteger
33},Positive {getPositive = LuaInteger 33},Positive {getPositive =
LuaInteger 34},Positive {getPositive = LuaInteger 34},Positive
{getPositive = LuaInteger 34},Positive {getPositive = LuaInteger
34},Positive {getPositive = LuaInteger 36},Positive {getPositive =
LuaInteger 37},Positive {getPositive = LuaInteger 39},Positive
{getPositive = LuaInteger 39},Positive {getPositive = LuaInteger
39},Positive {getPositive = LuaInteger 40},Positive {getPositive =
LuaInteger 41},Positive {getPositive = LuaInteger 44},Positive
{getPositive = LuaInteger 44},Positive {getPositive = LuaInteger
45},Positive {getPositive = LuaInteger 47},Positive {getPositive =
LuaInteger 50},Positive {getPositive = LuaInteger 51},Positive
{getPositive = LuaInteger 52},Positive {getPositive = LuaInteger
53},Positive {getPositive = LuaInteger 53}]}
          Use --quickcheck-replay=963253 to reproduce.
        can push/pop lists of LuaIntegers:                        FAIL
          *** Failed! Assertion failed (after 3 tests):
          [LuaInteger (-2)]
          Ordered {getOrdered = [Positive {getPositive = LuaInteger
1},Positive {getPositive = LuaInteger 1}]}
          Use --quickcheck-replay=230659 to reproduce.
        can push/pop lists of bytestrings:                        FAIL
          *** Failed! Assertion failed (after 3 tests and 2 shrinks):
          [""]
          Ordered {getOrdered = [Positive {getPositive = LuaInteger
1},Positive {getPositive = LuaInteger 2}]}
          Use --quickcheck-replay=39280 to reproduce.
    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:                FAIL
        test/Foreign/Lua/Types/FromLuaStackTest.hs:61:
        error message mismatched
        expected: Left "Could not read list: Expected a number but got a
boolean"
         but got: Left "Could not read list: Expected a number but got a
nil"
      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:                       OK
        LuaIntegers can be pushed correctly:                      OK
        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
(0.01s)
          +++ 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:                                                FAIL
      Exception: Expected a string but got a nil
    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

8 out of 113 tests failed (1.30s)
Test suite test-hslua: FAIL
Test suite logged to: dist/test/hslua-0.9.5.2-test-hslua.log
0 of 1 test suites (0 of 1 test cases) passed.
Backtrace:
           5 (primitive-load "/gnu/store/8m1laknzqkxb8swcxlq5vj4m717…")
In ice-9/eval.scm:
   191:35  4 (_ _)
In srfi/srfi-1.scm:
   863:16  3 (every1 #<procedure 82603a0 at /gnu/store/n944icv9i660…> …)
In
/gnu/store/n944icv9i660rrirykgv1yrvyazpkjrz-module-import/guix/build/gnu-build-system.scm:
   799:28  2 (_ _)
In
/gnu/store/n944icv9i660rrirykgv1yrvyazpkjrz-module-import/guix/build/haskell-build-system.scm:
    258:6  1 (check #:tests? _ #:test-target _)
In
/gnu/store/n944icv9i660rrirykgv1yrvyazpkjrz-module-import/guix/build/utils.scm:
    616:6  0 (invoke _ . _)

/gnu/store/n944icv9i660rrirykgv1yrvyazpkjrz-module-import/guix/build/utils.scm:616:6:
In procedure invoke:
Throw to key `srfi-34' with args `(#<condition &invoke-error [program:
"runhaskell" arguments: ("Setup.hs" "test") exit-status: 1 term-signal:
#f stop-signal: #f] 80aafc0>)'.
note: keeping build directory `/tmp/guix-build-ghc-hslua-0.9.5.2.drv-0'
builder for
`/gnu/store/d6ysq3vrm3ymjvwbivxja456zwhl74n0-ghc-hslua-0.9.5.2.drv'
failed with exit code 1
build of
/gnu/store/d6ysq3vrm3ymjvwbivxja456zwhl74n0-ghc-hslua-0.9.5.2.drv failed
View build log at
'/var/log/guix/drvs/d6/ysq3vrm3ymjvwbivxja456zwhl74n0-ghc-hslua-0.9.5.2.drv.bz2'.
guix build: error: build failed: build of
`/gnu/store/d6ysq3vrm3ymjvwbivxja456zwhl74n0-ghc-hslua-0.9.5.2.drv'
failed

-- 
Cheers 
Swedebugia