Merge branch 'master' of http://darcs.haskell.org/testsuite

testsuite/driver/testglobals.py

@@ -144,7 +144,6 @@ def getTestRun():
 
 class TestOptions:
    def __init__(self):
-
        # if not None then we look for namebase.stderr etc rather than
        # using the test name
        self.with_namebase = None
@@ -253,6 +252,9 @@ class TestOptions:
        # The directory the test is in
        self.testdir = '.'
 
+       # Should we redirect stdout and stderr to a single file?
+       self.combined_output = False
+
 # The default set of options
 global default_testopts
 default_testopts = TestOptions()

testsuite/driver/testlib.py

@@ -141,6 +141,9 @@ def ignore_output( opts ):
 def no_stdin( opts ):
     opts.no_stdin = 1
 
+def combined_output( opts ):
+    opts.combined_output = True
+
 # -----
 
 def expect_fail_for( ways ):
@@ -1155,11 +1158,18 @@ def simple_run( name, way, prog, args ):
         stdin_comes_from = ''
     else:
         stdin_comes_from = ' <' + use_stdin
+
+    if opts.combined_output:
+        redirection = ' >' + run_stdout \
+                    + ' 2>&1'
+    else:
+        redirection = ' >' + run_stdout \
+                    + ' 2>' + run_stderr
+
     cmd = prog + ' ' + args + ' '  \
         + my_rts_flags + ' '       \
         + stdin_comes_from         \
-        + ' >' + run_stdout        \
-        + ' 2>' + run_stderr
+        + redirection
 
     if getTestOpts().cmd_wrapper != None:
         cmd = getTestOpts().cmd_wrapper(cmd);
@@ -1183,7 +1193,7 @@ def simple_run( name, way, prog, args ):
     check_prof = my_rts_flags.find("-p") != -1
 
     if not opts.ignore_output:
-        if not check_stderr_ok(name):
+        if not opts.combined_output and not check_stderr_ok(name):
             return failBecause('bad stderr')
         if not check_stdout_ok(name):
             return failBecause('bad stdout')
@@ -1445,7 +1455,7 @@ def check_stderr_ok( name ):
       if platform_specific:
          return str
       else:
-         return normalise_output(str)
+         return normalise_errmsg(str)
 
    return compare_outputs('stderr', \
                           two_normalisers(norm, getTestOpts().extra_normaliser), \

testsuite/tests/ghci.debugger/scripts/all.T

@@ -44,20 +44,20 @@ test('break006', normal, ghci_script, ['break006.script'])
 test('break007', extra_clean(['Break007.o', 'Break007.hi']),
      ghci_script, ['break007.script'])
 test('break008', normal, ghci_script, ['break008.script'])
-test('break009', normal, ghci_script, ['break009.script'])
+test('break009', combined_output, ghci_script, ['break009.script'])
 test('break010', normal, ghci_script, ['break010.script'])
-test('break011', normal, ghci_script, ['break011.script'])
+test('break011', combined_output, ghci_script, ['break011.script'])
 test('break012', normal, ghci_script, ['break012.script'])
 test('break013', normal, ghci_script, ['break013.script'])
 test('break014', normal, ghci_script, ['break014.script'])
 test('break015', expect_broken(1532), ghci_script, ['break015.script'])
-test('break016', normal, ghci_script, ['break016.script'])
-test('break017', normal, ghci_script, ['break017.script'])
+test('break016', combined_output, ghci_script, ['break016.script'])
+test('break017', combined_output, ghci_script, ['break017.script'])
 test('break018', normal, ghci_script, ['break018.script'])
 test('break019', normal, ghci_script, ['break019.script'])
 test('break020', normal, ghci_script, ['break020.script'])
 test('break021', normal, ghci_script, ['break021.script'])
-test('break024', normal, ghci_script, ['break024.script'])
+test('break024', combined_output, ghci_script, ['break024.script'])
 test('break025', normal, ghci_script, ['break025.script'])
 test('break026', normal, ghci_script, ['break026.script'])
 test('break027', normal, ghci_script, ['break027.script'])
@@ -74,7 +74,7 @@ test('dynbrk009', normal, ghci_script, ['dynbrk009.script'])
 
 test('result001', expect_broken(1531), ghci_script, ['result001.script'])
 
-test('listCommand001', normal, ghci_script, ['listCommand001.script'])
+test('listCommand001', combined_output, ghci_script, ['listCommand001.script'])
 test('listCommand002', normal, ghci_script, ['listCommand002.script'])
 
 test('hist001', normal, ghci_script, ['hist001.script'])

testsuite/tests/ghci/scripts/Defer02.stderr

@@ -75,6 +75,25 @@
     In the first argument of `(>>)', namely `putChar'
     In the expression: putChar >> putChar 'p'
     In an equation for `l': l = putChar >> putChar 'p'
+*** Exception: ../../typecheck/should_run/Defer01.hs:11:40:
+    Couldn't match type `Char' with `[Char]'
+    Expected type: String
+      Actual type: Char
+    In the first argument of `putStr', namely ','
+    In the second argument of `(>>)', namely putStr ','
+    In the expression: putStr "Hello World" >> putStr ','
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:14:5:
+    Couldn't match expected type `Int' with actual type `Char'
+    In the expression: 'p'
+    In an equation for `a': a = 'p'
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:18:9:
+    No instance for (Eq B) arising from a use of `=='
+    Possible fix: add an instance declaration for (Eq B)
+    In the expression: x == x
+    In an equation for `b': b x = x == x
+(deferred type error)
 
 <interactive>:8:11:
     Couldn't match type `Bool' with `Int'
@@ -83,9 +102,49 @@
     In the return type of a call of `C2'
     In the first argument of `c', namely `(C2 True)'
     In the first argument of `print', namely `(c (C2 True))'
+*** Exception: ../../typecheck/should_run/Defer01.hs:28:5:
+    No instance for (Num (a -> a)) arising from the literal `1'
+    Possible fix: add an instance declaration for (Num (a -> a))
+    In the expression: 1
+    In an equation for `d': d = 1
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:31:5:
+    Couldn't match expected type `Char -> t' with actual type `Char'
+    The function `e' is applied to one argument,
+    but its type `Char' has none
+    In the expression: e 'q'
+    In an equation for `f': f = e 'q'
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:34:8:
+    Couldn't match expected type `a' with actual type `Char'
+      `a' is a rigid type variable bound by
+          the type signature for h :: a -> (Char, Char)
+          at ../../typecheck/should_run/Defer01.hs:33:6
+    In the expression: x
+    In the expression: (x, 'c')
+    In an equation for `h': h x = (x, 'c')
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:39:17:
+    Couldn't match expected type `Bool' with actual type `T a'
+    In the return type of a call of `K'
+    In the first argument of `not', namely `(K a)'
+    In the expression: (not (K a))
+(deferred type error)
+*** Exception: ../../typecheck/should_run/Defer01.hs:43:5:
+    No instance for (MyClass a1) arising from a use of `myOp'
+    In the expression: myOp 23
+    In an equation for `j': j = myOp 23
+(deferred type error)
 
 <interactive>:14:8:
     Couldn't match expected type `Bool' with actual type `Int'
     In the first argument of `print', namely `(k 2)'
     In the expression: print (k 2)
     In an equation for `it': it = print (k 2)
+*** Exception: ../../typecheck/should_run/Defer01.hs:49:5:
+    Couldn't match expected type `IO a0'
+                with actual type `Char -> IO ()'
+    In the first argument of `(>>)', namely `putChar'
+    In the expression: putChar >> putChar 'p'
+    In an equation for `l': l = putChar >> putChar 'p'
+(deferred type error)

testsuite/tests/ghci/scripts/Defer02.stdout

-Hello World*** Exception: ../../typecheck/should_run/Defer01.hs:11:40:
-    Couldn't match type `Char' with `[Char]'
-    Expected type: String
-      Actual type: Char
-    In the first argument of `putStr', namely ','
-    In the second argument of `(>>)', namely putStr ','
-    In the expression: putStr "Hello World" >> putStr ','
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:14:5:
-    Couldn't match expected type `Int' with actual type `Char'
-    In the expression: 'p'
-    In an equation for `a': a = 'p'
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:18:9:
-    No instance for (Eq B) arising from a use of `=='
-    Possible fix: add an instance declaration for (Eq B)
-    In the expression: x == x
-    In an equation for `b': b x = x == x
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:28:5:
-    No instance for (Num (a -> a)) arising from the literal `1'
-    Possible fix: add an instance declaration for (Num (a -> a))
-    In the expression: 1
-    In an equation for `d': d = 1
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:31:5:
-    Couldn't match expected type `Char -> t' with actual type `Char'
-    The function `e' is applied to one argument,
-    but its type `Char' has none
-    In the expression: e 'q'
-    In an equation for `f': f = e 'q'
-(deferred type error)
-(*** Exception: ../../typecheck/should_run/Defer01.hs:34:8:
-    Couldn't match expected type `a' with actual type `Char'
-      `a' is a rigid type variable bound by
-          the type signature for h :: a -> (Char, Char)
-          at ../../typecheck/should_run/Defer01.hs:33:6
-    In the expression: x
-    In the expression: (x, 'c')
-    In an equation for `h': h x = (x, 'c')
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:39:17:
-    Couldn't match expected type `Bool' with actual type `T a'
-    In the return type of a call of `K'
-    In the first argument of `not', namely `(K a)'
-    In the expression: (not (K a))
-(deferred type error)
-"*** Exception: ../../typecheck/should_run/Defer01.hs:43:5:
-    No instance for (MyClass a1) arising from a use of `myOp'
-    In the expression: myOp 23
-    In an equation for `j': j = myOp 23
-(deferred type error)
-*** Exception: ../../typecheck/should_run/Defer01.hs:49:5:
-    Couldn't match expected type `IO a0'
-                with actual type `Char -> IO ()'
-    In the first argument of `(>>)', namely `putChar'
-    In the expression: putChar >> putChar 'p'
-    In an equation for `l': l = putChar >> putChar 'p'
-(deferred type error)
+Hello World("
\ No newline at end of file

testsuite/tests/ghci/scripts/all.T

@@ -2,15 +2,15 @@
 
 setTestOpts(if_compiler_profiled(skip))
 
-test('ghci001', normal, ghci_script, ['ghci001.script'])
-test('ghci002', normal, ghci_script, ['ghci002.script'])
-test('ghci003', normal, ghci_script, ['ghci003.script'])
-test('ghci004', normal, ghci_script, ['ghci004.script'])
-test('ghci005', normal, ghci_script, ['ghci005.script'])
-test('ghci006', normal, ghci_script, ['ghci006.script'])
-test('ghci007', normal, ghci_script, ['ghci007.script'])
-test('ghci008', normal, ghci_script, ['ghci008.script'])
-test('ghci009', normal, ghci_script, ['ghci009.script'])
+test('ghci001', combined_output, ghci_script, ['ghci001.script'])
+test('ghci002', combined_output, ghci_script, ['ghci002.script'])
+test('ghci003', combined_output, ghci_script, ['ghci003.script'])
+test('ghci004', combined_output, ghci_script, ['ghci004.script'])
+test('ghci005', combined_output, ghci_script, ['ghci005.script'])
+test('ghci006', combined_output, ghci_script, ['ghci006.script'])
+test('ghci007', combined_output, ghci_script, ['ghci007.script'])
+test('ghci008', combined_output, ghci_script, ['ghci008.script'])
+test('ghci009', combined_output, ghci_script, ['ghci009.script'])
 
 # Skip this test: deadlock can't be detected now, because we wait for
 # signals to arrive if there are signal handlers installed, and GHCi
@@ -72,7 +72,7 @@ test('ghci051', normal, ghci_script, ['ghci051.script'])
 test('ghci052', normal, ghci_script, ['ghci052.script'])
 test('ghci053', normal, ghci_script, ['ghci053.script'])
 test('ghci054', normal, ghci_script, ['ghci054.script'])
-test('ghci055', normal, ghci_script, ['ghci055.script'])
+test('ghci055', combined_output, ghci_script, ['ghci055.script'])
 
 test('ghci056',
      [
@@ -107,7 +107,7 @@ test('T5045', normal, ghci_script, ['T5045.script'])
 test('T5130', normal, ghci_script, ['T5130.script'])
 test('T5417', normal, ghci_script, ['T5417.script'])
 test('T5545', normal, ghci_script, ['T5545.script'])
-test('T5557', normal, ghci_script, ['T5557.script'])
+test('T5557', combined_output, ghci_script, ['T5557.script'])
 test('T5566', normal, ghci_script, ['T5566.script'])
 test('GhciKinds', normal, ghci_script, ['GhciKinds.script'])
 test('T5564', normal, ghci_script, ['T5564.script'])

testsuite/tests/ghci/scripts/ghci044.stderr

@@ -7,7 +7,7 @@
        Use -XFlexibleInstances if you want to disable this.)
     In the instance declaration for `C [Int]'
 
-<interactive>:8:10:
+<interactive>:7:10:
     Overlapping instance declarations:
-      instance C a => C [a] -- Defined at <interactive>:8:10
       instance C [Int] -- Defined at <interactive>:7:10
+      instance C a => C [a] -- Defined at <interactive>:8:10

testsuite/tests/ghci/should_run/all.T

@@ -13,7 +13,8 @@ test('2881',    just_ghci, compile_and_run, [''])
 
 test('3171',
      [if_platform('i386-unknown-mingw32',skip),
-      req_interp],
+      req_interp,
+      combined_output],
      run_command,
      ['$MAKE -s --no-print-directory 3171'])
 

testsuite/tests/haddock/haddock_examples/haddock.Test.stderr

@@ -36,7 +36,7 @@ import Hidden
 import Visible
 <document comment>
 data T a b
-  = <document comment> A Int Maybe Float |
+  = <document comment> A Int (Maybe Float) |
     <document comment> B (T a b, T Int Float)
 <document comment>
 data T2 a b = T2 a b
@@ -126,7 +126,7 @@ data Ex a
   = forall b. C b => Ex1 b |
     forall b. Ex2 b |
     forall b. C a => Ex3 b |
-    Ex4 forall a. a -> a
+    Ex4 (forall a. a -> a)
 <document comment>
 k ::
   T () () <document comment>

testsuite/tests/indexed-types/should_fail/SimpleFail2b.stderr

 
-SimpleFail2b.hs:10:11:
+SimpleFail2b.hs:9:11:
     Conflicting family instance declarations:
-      data Sd Int -- Defined at SimpleFail2b.hs:10:11
       data Sd Int -- Defined at SimpleFail2b.hs:9:11
+      data Sd Int -- Defined at SimpleFail2b.hs:10:11

testsuite/tests/module/mod51.stderr

 
-mod51.hs:3:25:
+mod51.hs:3:22:
     Duplicate instance declarations:
-      instance Eq T -- Defined at mod51.hs:3:25
       instance Eq T -- Defined at mod51.hs:3:22
+      instance Eq T -- Defined at mod51.hs:3:25

testsuite/tests/numeric/should_run/all.T

@@ -56,4 +56,5 @@ test('4383', normal, compile_and_run, [''])
 
 test('add2', normal, compile_and_run, [''])
 test('mul2', normal, compile_and_run, [''])
+test('quotRem2', normal, compile_and_run, [''])
 

testsuite/tests/numeric/should_run/quotRem2.hs

+
+{-# LANGUAGE MagicHash, UnboxedTuples #-}
+
+import GHC.Prim
+import GHC.Word
+import Control.Monad
+import Data.Bits
+
+main :: IO ()
+main = do f 5 6 23
+          f 0x80000000 0 0x80000001
+          f 0xFC1D8A3BFB29FC6A 49 0xFD94E3B7FE36FB18
+
+f :: Word -> Word -> Word -> IO ()
+f wxHigh@(W# xHigh) wxLow@(W# xLow) wy@(W# y)
+    = do when debugging $ putStrLn "-----"
+         when debugging $ putStrLn ("Doing " ++ show (wxHigh, wxLow)
+                                             ++ " `quotRem` " ++ show wy)
+         let ix = (toInteger wxHigh `shiftL` bitSize wxHigh)
+              .|. toInteger wxLow
+             wanted = ix `quotRem` toInteger wy
+         when debugging $ putStrLn ("Wanted: " ++ show wanted)
+         case quotRemWord2# xHigh xLow y of
+             (# q, r #) ->
+                 do let wq = W# q
+                        wr = W# r
+                        got = (toInteger wq, toInteger wr)
+                    when debugging $ putStrLn ("Got: " ++ show got)
+                    if wanted == got then putStrLn "Worked"
+                                     else putStrLn "Failed"
+
+debugging :: Bool
+debugging = False
+

testsuite/tests/numeric/should_run/quotRem2.stdout

+Worked
+Worked
+Worked

testsuite/tests/safeHaskell/ghci/p12.stderr

+don't know how to reverse -XSafe
+Some flags have not been recognized: -fno-package-trust
 
 <no location info>:
     Data.ByteString: Can't be safely imported!

testsuite/tests/safeHaskell/ghci/p12.stdout

-don't know how to reverse -XSafe
-Some flags have not been recognized: -fno-package-trust

testsuite/tests/safeHaskell/ghci/p2.stderr

 package flags have changed, resetting and loading new packages...
 package flags have changed, resetting and loading new packages...
+cannot satisfy -package -all
+    (use -v for more information)

testsuite/tests/safeHaskell/ghci/p2.stdout

-cannot satisfy -package -all
-    (use -v for more information)

testsuite/tests/safeHaskell/ghci/p3.stderr

@@ -2,6 +2,7 @@
 <no location info>:
     System.IO.Unsafe: Can't be safely imported!
     The module itself isn't safe.
+can't import System.IO.Unsafe as it isn't trusted.
 
 <no location info>:
     Data.ByteString: Can't be safely imported!

testsuite/tests/safeHaskell/ghci/p3.stdout

-can't import System.IO.Unsafe as it isn't trusted.

testsuite/tests/th/T1835.stdout

 class GHC.Classes.Eq a_0 => Main.MyClass a_0
-instance Main.MyClass Main.Foo
+instance GHC.Classes.Ord a_1 => Main.MyClass (Main.Quux2 a_1)
+instance GHC.Classes.Eq a_2 => Main.MyClass (Main.Quux a_2)
 instance Main.MyClass Main.Baz
-instance GHC.Classes.Eq a_1 => Main.MyClass (Main.Quux a_1)
-instance GHC.Classes.Ord a_2 => Main.MyClass (Main.Quux2 a_2)
+instance Main.MyClass Main.Foo
 True
 True
 True

testsuite/tests/typecheck/should_compile/T2494.stderr

 
 T2494.hs:15:14:
-    Couldn't match type `a' with `b'
-      `a' is a rigid type variable bound by
-          the RULE "foo/foo" at T2494.hs:13:16
+    Couldn't match type `b' with `a'
       `b' is a rigid type variable bound by
           the RULE "foo/foo" at T2494.hs:14:16
+      `a' is a rigid type variable bound by
+          the RULE "foo/foo" at T2494.hs:13:16
     Expected type: Maybe (m a) -> Maybe (m a)
       Actual type: Maybe (m b) -> Maybe (m b)
     In the first argument of `foo', namely `g'

testsuite/tests/typecheck/should_fail/T5691.hs

+{-# LANGUAGE ScopedTypeVariables #-}
+
+module GHCBug where
+
+import Control.Applicative as Ap
+import Control.Monad (MonadPlus, mplus, mzero)
+import Control.Monad.Identity (Identity, runIdentity)
+
+newtype PrintRuleInterp v = MkPRI { printRule_ :: Int -> String }
+class Test p where
+  test :: p a -> p a
+
+instance Test PrintRuleInterp where
+  test (f :: p a) =
+    MkPRI $ printRule_ f 
+
+
+newtype RecDecParser a = MkRD {
+  parseRD :: String -> [(String, a)]
+  }
+
+pure_ v = MkRD $ \s -> pure (s , v)
+
+instance MonadPlus RecDecParser where
+  mzero = MkRD $ const Ap.empty
+  mplus a b = MkRD $ const Ap.empty
+
+
+

testsuite/tests/typecheck/should_fail/T5691.stderr

+
+T5691.hs:14:9:
+    Couldn't match type `p' with `PrintRuleInterp'
+    Expected type: p a
+      Actual type: PrintRuleInterp a
+    In the pattern: f :: p a
+    In an equation for `test': test (f :: p a) = MkPRI $ printRule_ f
+    In the instance declaration for `Test PrintRuleInterp'
+
+T5691.hs:24:10:
+    No instance for (Monad RecDecParser)
+      arising from the superclasses of an instance declaration
+    Possible fix: add an instance declaration for (Monad RecDecParser)
+    In the instance declaration for `MonadPlus RecDecParser'

testsuite/tests/typecheck/should_fail/all.T

@@ -268,6 +268,7 @@ test('T3592', normal, compile_fail, [''])
 test('T5570', normal, compile_fail, [''])
 test('T5573a', normal, compile_fail, [''])
 test('T5573b', normal, compile_fail, [''])
+test('T5691', normal, compile_fail, [''])
 test('T5689', normal, compile_fail, [''])
 test('T5684', normal, compile_fail, [''])
 test('T5858', normal, compile_fail, [''])

testsuite/tests/typecheck/should_fail/tcfail043.stderr

@@ -29,8 +29,8 @@ tcfail043.hs:40:25:
     Probable fix: give these definition(s) an explicit type signature
                   or use -XNoMonomorphismRestriction
     Note: there are several potential instances:
-      instance Eq_ a => Eq_ [a] -- Defined at tcfail043.hs:23:10
       instance Eq_ Int -- Defined at tcfail043.hs:20:10
+      instance Eq_ a => Eq_ [a] -- Defined at tcfail043.hs:23:10
     In the expression: eq a (hd bs)
     In the expression: if eq a (hd bs) then True else search a (tl bs)
     In the expression: