[GHC] #5757: zero unexpected failures on all tier 1 platforms

[GHC]

#5757: zero unexpected failures on all tier 1 platforms
---------------------------------+------------------------------------------
    Reporter:  simonmar          |       Owner:                  
        Type:  task              |      Status:  new             
    Priority:  highest           |   Milestone:  7.4.2           
   Component:  Test Suite        |     Version:  7.2.1           
    Keywords:                    |          Os:  Unknown/Multiple
Architecture:  Unknown/Multiple  |     Failure:  None/Unknown    
  Difficulty:  Unknown           |    Testcase:                  
   Blockedby:                    |    Blocking:                  
     Related:  #5785, #5757      |  
---------------------------------+------------------------------------------

Comment(by nomeata):

 Here are the unexpected failures on Debian, amd64, 7.4.1 with the released
 testsuite, FAST mode:

 {{{
 OVERALL SUMMARY for test run started at Mon Feb 13 20:16:45 UTC 2012
     3036 total tests, which gave rise to
    12716 test cases, of which
        0 caused framework failures
     9956 were skipped

     2714 expected passes
       42 expected failures
        0 unexpected passes
        4 unexpected failures

 Unexpected failures:
    codeGen/should_run   cgrun025 [exit code non-0] (normal)
    deriving/should_run  T3087 [exit code non-0] (normal)
    lib/Concurrent       QSemN001 [bad exit code] (normal)
    lib/Regex            regex003 [exit code non-0] (normal)

 =====> cgrun025(normal) 2613 of 3036 [0, 2, 0]
 cd ./codeGen/should_run && '/usr/bin/ghc' -fforce-recomp -dcore-lint
 -dcmm-lint -dno-debug-output -no-user-package-conf -rtsopts  -fno-ghci-
 history -o cgrun025 cgrun025.hs  -package regex-compat
 >cgrun025.comp.stderr 2>&1
 Compile failed (status 256) errors were:

 cgrun025.hs:8:8:
     Could not find module `Maybe'
     It is a member of the hidden package `haskell98-2.0.0.1'.
     Use -v to see a list of the files searched for.

 *** unexpected failure for cgrun025(normal)


 =====> T3087(normal) 2967 of 3036 [0, 3, 0]
 cd ./deriving/should_run && '/usr/bin/ghc' -fforce-recomp -dcore-lint
 -dcmm-lint -dno-debug-output -no-user-package-conf -rtsopts  -fno-ghci-
 history -o T3087 T3087.hs  -package syb  >T3087.comp.stderr 2>&1
 Compile failed (status 256) errors were:
 [1 of 1] Compiling Main             ( T3087.hs, T3087.o )

 T3087.hs:28:19:
     Ambiguous occurrence `ext2Q'
     It could refer to either `Main.ext2Q', defined at T3087.hs:20:1
                           or `Data.Generics.ext2Q',
                              imported from `Data.Generics' at
 T3087.hs:5:1-20
                              (and originally defined in
 `Data.Generics.Aliases')

 T3087.hs:31:20:
     Ambiguous occurrence `ext2Q'
     It could refer to either `Main.ext2Q', defined at T3087.hs:20:1
                           or `Data.Generics.ext2Q',
                              imported from `Data.Generics' at
 T3087.hs:5:1-20
                              (and originally defined in
 `Data.Generics.Aliases')

 *** unexpected failure for T3087(normal)



 =====> QSemN001(normal) 1494 of 3036 [0, 0, 0]
 cd ./lib/Concurrent && '/usr/bin/ghc' -fforce-recomp -dcore-lint -dcmm-
 lint -dno-debug-output -no-user-package-conf -rtsopts  -fno-ghci-history
 -o QSemN001 QSemN001.hs  -package QuickCheck  >QSemN001.comp.stderr 2>&1
 cd ./lib/Concurrent && ./QSemN001    </dev/null >QSemN001.run.stdout
 2>QSemN001.run.stderr
 Wrong exit code (expected 0 , actual 1 )
 Stdout:

 Stderr:
 QSemN001: user error (newQSemN: Initial quantity must be non-negative)

 *** unexpected failure for QSemN001(normal)

 =====> regex003(normal) 1563 of 3036 [0, 1, 0]
 cd ./lib/Regex && '/usr/bin/ghc' -fforce-recomp -dcore-lint -dcmm-lint
 -dno-de
 bug-output -no-user-package-conf -rtsopts  -fno-ghci-history -o regex003
 regex
 003.hs  -package regex-posix  >regex003.comp.stderr 2>&1
 Compile failed (status 256) errors were:
 [1 of 1] Compiling Main             ( regex003.hs, regex003.o )

 regex003.hs:7:12:
     Non type-variable argument
       in the constraint: RegexContext Regex String target
     (Use -XFlexibleContexts to permit this)
     In the type signature for `x':
       x :: RegexContext Regex String target => target
     In the expression:
       let
         x :: RegexContext Regex String target => target
         x = ("abaca" =~ B.pack "(.)a")
         x' :: (RegexContext Regex String target, Monad m) => m target
         ....
       in
         do { print (x :: Bool);
              print (x :: Int);
              print (x :: [MatchArray]);
              .... }
     In an equation for `main':
         main
           = let
               x :: RegexContext Regex String target => target
               x = ("abaca" =~ B.pack "(.)a")
               ....
             in
               do { print (x :: Bool);
                    print (x :: Int);
                    .... }

 regex003.hs:11:12:
     Non type-variable argument
       in the constraint: RegexContext Regex B.ByteString target
     (Use -XFlexibleContexts to permit this)
     In the type signature for `y':
       y :: RegexContext Regex B.ByteString target => target
     In the expression:
       let
         x :: RegexContext Regex String target => target
         x = ("abaca" =~ B.pack "(.)a")
         x' :: (RegexContext Regex String target, Monad m) => m target
         ....
       in
         do { print (x :: Bool);
              print (x :: Int);
              print (x :: [MatchArray]);
              .... }
     In an equation for `main':
         main
           = let
               x :: RegexContext Regex String target => target
               x = ("abaca" =~ B.pack "(.)a")
               ....
             in
               do { print (x :: Bool);
                    print (x :: Int);
                    .... }
 regex003.hs:13:12:
     Non type-variable argument
       in the constraint: RegexContext Regex B.ByteString target
     (Use -XFlexibleContexts to permit this)
     In the type signature for y':
       y' :: (RegexContext Regex B.ByteString target, Monad m) => m target
     In the expression:
       let
         x :: RegexContext Regex String target => target
         x = ("abaca" =~ B.pack "(.)a")
         x' :: (RegexContext Regex String target, Monad m) => m target
         ....
       in
         do { print (x :: Bool);
              print (x :: Int);
              print (x :: [MatchArray]);
              .... }
     In an equation for `main':
         main
           = let
               x :: RegexContext Regex String target => target
               x = ("abaca" =~ B.pack "(.)a")
               ....
             in
               do { print (x :: Bool);
                    print (x :: Int);
                    .... }

 *** unexpected failure for regex003(normal)
 }}}

-- 
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/5757#comment:12>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler