Commit f0821355 authored by Simon Peyton Jones's avatar Simon Peyton Jones

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

parents cead06ef 9ff81c7f
......@@ -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()
......
......@@ -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), \
......
......@@ -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'])
......
../../typecheck/should_run/Defer01.hs:11:40: Warning:
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 ','
../../typecheck/should_run/Defer01.hs:14:5: Warning:
Couldn't match expected type `Int' with actual type `Char'
In the expression: 'p'
In an equation for `a': a = 'p'
../../typecheck/should_run/Defer01.hs:18:9: Warning:
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
../../typecheck/should_run/Defer01.hs:28:5: Warning:
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
../../typecheck/should_run/Defer01.hs:31:5: Warning:
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'
../../typecheck/should_run/Defer01.hs:34:8: Warning:
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')
../../typecheck/should_run/Defer01.hs:39:17: Warning:
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))
../../typecheck/should_run/Defer01.hs:43:5: Warning:
No instance for (MyClass a1) arising from a use of `myOp'
In the expression: myOp 23
In an equation for `j': j = myOp 23
../../typecheck/should_run/Defer01.hs:43:10: Warning:
No instance for (Num a1) arising from the literal `23'
The type variable `a1' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there are several potential instances:
instance Num Double -- Defined in `GHC.Float'
instance Num Float -- Defined in `GHC.Float'
instance Num Int -- Defined in `GHC.Num'
...plus one other
In the first argument of `myOp', namely `23'
In the expression: myOp 23
In an equation for `j': j = myOp 23
../../typecheck/should_run/Defer01.hs:46:7: Warning:
Couldn't match expected type `Bool' with actual type `Int'
In the expression: x
In an equation for `k': k x = x
../../typecheck/should_run/Defer01.hs:49:5: Warning:
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'
<interactive>:8:11:
Couldn't match type `Bool' with `Int'
Expected type: C Int
Actual type: C Bool
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))'
<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)
../../typecheck/should_run/Defer01.hs:11:40: Warning:
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 ','
../../typecheck/should_run/Defer01.hs:14:5: Warning:
Couldn't match expected type `Int' with actual type `Char'
In the expression: 'p'
In an equation for `a': a = 'p'
../../typecheck/should_run/Defer01.hs:18:9: Warning:
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
../../typecheck/should_run/Defer01.hs:28:5: Warning:
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
../../typecheck/should_run/Defer01.hs:31:5: Warning:
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'
../../typecheck/should_run/Defer01.hs:34:8: Warning:
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')
../../typecheck/should_run/Defer01.hs:39:17: Warning:
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))
../../typecheck/should_run/Defer01.hs:43:5: Warning:
No instance for (MyClass a1) arising from a use of `myOp'
In the expression: myOp 23
In an equation for `j': j = myOp 23
../../typecheck/should_run/Defer01.hs:43:10: Warning:
No instance for (Num a1) arising from the literal `23'
The type variable `a1' is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there are several potential instances:
instance Num Double -- Defined in `GHC.Float'
instance Num Float -- Defined in `GHC.Float'
instance Num Int -- Defined in `GHC.Num'
...plus one other
In the first argument of `myOp', namely `23'
In the expression: myOp 23
In an equation for `j': j = myOp 23
../../typecheck/should_run/Defer01.hs:46:7: Warning:
Couldn't match expected type `Bool' with actual type `Int'
In the expression: x
In an equation for `k': k x = x
../../typecheck/should_run/Defer01.hs:49:5: Warning:
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'
*** 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'
Expected type: C Int
Actual type: C Bool
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)
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
......@@ -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'])
......
......@@ -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
......@@ -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'])
......
[1 of 3] Compiling Visible ( Visible.hs, Visible.o )
==================== Parser ====================
module Visible where
visible :: Int -> Int
visible a = a
[2 of 3] Compiling Hidden ( Hidden.hs, Hidden.o )
==================== Parser ====================
module Hidden where
hidden :: Int -> Int
hidden a = a
[3 of 3] Compiling Test ( Test.hs, Test.o )
==================== Parser ====================
<document comment>
module Test (
<IEGroup: 1>, <IEGroup: 2>, T(..), T2, T3(..), T4(..), T5(..),
T6(..), N1(..), N2(..), N3(..), N4, N5(..), N6(..), N7(..),
<IEGroup: 2>, R(..), R1(..), <document comment>, p, q, u,
<IEGroup: 1>, C(a, b), D(..), E, F(..), <document comment>, a,
<IEGroup: 1>, f, g, <IEGroup: 1>, <IEDocNamed: aux1>,
<IEDocNamed: aux2>, <IEDocNamed: aux3>, <IEDocNamed: aux4>,
<IEDocNamed: aux5>, <IEDocNamed: aux6>, <IEDocNamed: aux7>,
<IEDocNamed: aux8>, <IEDocNamed: aux9>, <IEDocNamed: aux10>,
<IEDocNamed: aux11>, <IEDocNamed: aux12>, <document comment>,
<IEGroup: 1>, module Hidden, <IEGroup: 1>, module Visible,
<document comment>, <IEGroup: 1>, Ex(..), <IEGroup: 1>, k, l, m, o,
<IEGroup: 1>, <IEGroup: 2>, <document comment>, f'
) where
import Hidden
import Visible
<document comment>
data T a b
= <document comment> A Int Maybe Float |
<document comment> B (T a b, T Int Float)
<document comment>
data T2 a b = T2 a b
<document comment>
data T3 a b = A1 a | B1 b
data T4 a b = A2 a | B2 b
data T5 a b = <document comment> A3 a | <document comment> B3 b
<document comment>
data T6
= <document comment> A4 |
<document comment> B4 |
<document comment> C4
<document comment>
newtype N1 a = N1 a
<document comment>
newtype N2 a b = N2 {n :: a b}
<document comment>
newtype N3 a b = N3 {n3 :: a b <document comment>}
<document comment>
newtype N4 a b = N4 a
newtype N5 a b = N5 {n5 :: a b <document comment>}
newtype N6 a b = <document comment> N6 {n6 :: a b}
<document comment>
newtype N7 a b = <document comment> N7 {n7 :: a b}
class D a => C a where
a :: IO a
b :: [a]
c :: a
<document comment>
class D a where
d :: T a b
e :: (a, a)
<document comment>
instance D Int where
d = undefined
e = undefined
instance Test.D Float where
d = undefined
e = undefined
class E a where
ee :: a
<document comment>
class F a where
ff :: a
<document comment>
data R
= <document comment>
C1 {p :: Int <document comment>,
q :: forall a. a -> a <document comment>,
r :: Int <document comment>,
s :: Int <document comment>} |
<document comment>
C2 {t :: T1
-> (T2 Int Int) -> (T3 Bool Bool) -> (T4 Float Float) -> T5 () (),
u :: Int,
v :: Int}
<document comment>
data R1
= <document comment>
C3 {s1 :: Int <document comment>,
s2 :: Int <document comment>,
s3 :: Int <document comment>}
<document comment>
<document comment>
<document comment>
<document comment>
f :: C a => a -> Int
<document comment>
foreign import ccall safe "static header.h g" g :: Int -> IO CInt
<document comment>
h :: Int
h = 42
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
<document comment>
data Ex a
= forall b. C b => Ex1 b |
forall b. Ex2 b |
forall b. C a => Ex3 b |
Ex4 forall a. a -> a
<document comment>
k ::
T () () <document comment>
-> (T2 Int Int) <document comment>
-> (T3 Bool Bool -> T4 Float Float) <document comment>
-> T5 () () <document comment> -> IO () <document comment>
l :: (Int, Int, Float) <document comment> -> Int <document comment>
<document comment>
m :: R -> N1 () <document comment> -> IO Int <document comment>
<document comment>
newn :: R <document comment> -> N1 () <document comment> -> IO Int
newn = undefined
<document comment>
foreign import ccall unsafe "static header.h o" o
:: Float <document comment> -> IO Float <document comment>
<document comment>
newp :: Int
newp = undefined
<document comment>
f' :: Int
data T1
f = undefined
f' = undefined
type CInt = Int
k = undefined
l = undefined
m = undefined
Test.hs:32:9: Warning: `p' is exported by `p' and `R(..)'
Test.hs:32:12: Warning: `q' is exported by `q' and `R(..)'