From 33ab68b67ce865cd6447b41eda6d64ed0f65e8d9 Mon Sep 17 00:00:00 2001 From: David Waern Date: Sat, 12 Apr 2008 18:57:23 +0000 Subject: Simplify test suite and add tests I move all tests into one single directory to simplify things, and add a test for the last bug that was fixed. --- tests/output/Test.html | 3105 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3105 insertions(+) create mode 100644 tests/output/Test.html (limited to 'tests/output/Test.html') diff --git a/tests/output/Test.html b/tests/output/Test.html new file mode 100644 index 00000000..38df4004 --- /dev/null +++ b/tests/output/Test.html @@ -0,0 +1,3105 @@ + + +Test
 ContentsIndex
Test
Portabilityportable
Stabilityprovisional
Maintainerlibraries@haskell.org
Contents
Type declarations +
Data types +
Records +
Class declarations +
Function types +
Auxiliary stuff +
A hidden module +
A visible module +
Existential / Universal types +
Type signatures with argument docs +
A section +
A subsection +
Description
This module illustrates & tests most of the features of Haddock. + Testing references from the description: T, f, g, visible. +
Synopsis
data T a b
= A Int (Maybe Float)
| B (T a b, T Int Float)
data T2 a b
data T3 a b
= A1 a
| B1 b
data T4 a b
= A2 a
| B2 b
data T5 a b
= A3 a
| B3 b
data T6
= A4
| B4
| C4
newtype N1 a = N1 a
newtype N2 a b = N2 {
n :: a b
}
newtype N3 a b = N3 {
n3 :: a b
}
data N4 a b
newtype N5 a b = N5 {
n5 :: a b
}
newtype N6 a b = N6 {
n6 :: a b
}
newtype N7 a b = N7 {
n7 :: a b
}
data R
= C1 {
p :: Int
q :: forall a. a -> a
r :: Int
s :: Int
}
| C2 {
t :: T1 -> (T2 Int Int) -> (T3 Bool Bool) -> (T4 Float Float) -> T5 () ()
u :: Int
v :: Int
}
data R1 = C3 {
s1 :: Int
s2 :: Int
s3 :: Int
}
p :: R -> Int
q :: R -> forall a. a -> a
u :: R -> Int
class D a => C a where
a :: IO a
b :: [a]
class D a where
d :: T a b
e :: (a, a)
class E a
class F a where
ff :: a
a :: C a => IO a
f :: C a => a -> Int
g :: Int -> IO CInt
hidden :: Int -> Int
module Visible
data Ex a
= forall b . C b => Ex1 b
| forall b . Ex2 b
| forall b . C a => Ex3 b
| Ex4 (forall a. a -> a)
k :: T () () -> T2 Int Int -> T3 Bool Bool -> T4 Float Float -> T5 () () -> IO ()
l :: (Int, Int, Float) -> Int
m :: R -> N1 () -> IO Int
o :: Float -> IO Float
f' :: Int
Type declarations +
Data types +
data T a b
This comment applies to the following declaration + and it continues until the next non-comment line +
Constructors
A Int (Maybe Float)This comment describes the A constructor +
B (T a b, T Int Float)This comment describes the B constructor +
data T2 a b
An abstract data declaration +
data T3 a b
A data declaration with no documentation annotations on the constructors +
Constructors
A1 a
B1 b
data T4 a b
Constructors
A2 a
B2 b
data T5 a b
Constructors
A3 adocuments A3 +
B3 bdocuments B3 +
data T6
Testing alternative comment styles +
Constructors
A4This is the doc for A4 +
B4This is the doc for B4 +
C4This is the doc for C4 +
newtype N1 a
A newtype +
Constructors
N1 a
newtype N2 a b
A newtype with a fieldname +
Constructors
N2
n :: a b
newtype N3 a b
A newtype with a fieldname, documentation on the field +
Constructors
N3
n3 :: a bthis is the n3 field +
data N4 a b
An abstract newtype - we show this one as data rather than newtype because + the difference isn't visible to the programmer for an abstract type. +
newtype N5 a b
Constructors
N5
n5 :: a bno docs on the datatype or the constructor +
newtype N6 a b
Constructors
N6docs on the constructor only +
n6 :: a b
newtype N7 a b
docs on the newtype and the constructor +
Constructors
N7The N7 constructor +
n7 :: a b
Records +
data R
This is the documentation for the R record, which has four fields, + p, q, r, and s. +
Constructors
C1This is the C1 record constructor, with the following fields: +
p :: IntThis comment applies to the p field +
q :: forall a. a -> aThis comment applies to the q field +
r :: IntThis comment applies to both r and s +
s :: IntThis comment applies to both r and s +
C2This is the C2 record constructor, also with some fields: +
t :: T1 -> (T2 Int Int) -> (T3 Bool Bool) -> (T4 Float Float) -> T5 () ()
u :: Int
v :: Int
data R1
Testing different record commenting styles +
Constructors
C3This is the C3 record constructor +
s1 :: IntThe s1 record selector +
s2 :: IntThe s2 record selector +
s3 :: IntThe s3 record selector +
test that we can export record selectors on their own: +
p :: R -> Int
This comment applies to the p field +
q :: R -> forall a. a -> a
This comment applies to the q field +
u :: R -> Int
Class declarations +
class D a => C a where
This comment applies to the previous declaration (the C class) +
Methods
a :: IO a
this is a description of the a method +
b :: [a]
this is a description of the b method +
class D a where
This is a class declaration with no separate docs for the methods +
Methods
d :: T a b
e :: (a, a)
class E a
This is a class declaration with no methods (or no methods exported) +
class F a where
Methods
ff :: a
Test that we can export a class method on its own: +
a :: C a => IO a
this is a description of the a method +
Function types +
f :: C a => a -> Int

In a comment string we can refer to identifiers in scope with +single quotes like this: T, and we can refer to modules by +using double quotes: Foo. We can add emphasis like this. +

  • This is a bulleted list +
  • This is the next item (different kind of bullet) +
  1. This is an ordered list +

2. This is the next item (different kind of bullet) +

+     This is a block of code, which can include other markup: R
+     formatting
+               is
+                 significant
+
 this is another block of code
+

We can also include URLs in documentation: http://www.haskell.org/. +

g :: Int -> IO CInt
we can export foreign declarations too +
Auxiliary stuff +

This is some documentation that is attached to a name ($aux1) + rather than a source declaration. The documentation may be + referred to in the export list using its name. +

 code block in named doc
This is some documentation that is attached to a name ($aux2) +
 code block on its own in named doc
 code block on its own in named doc (after newline)

a nested, named doc comment +

with a paragraph, +

 and a code block
test
+test1
+
 test2
+  test3
+
+test1
+test2
+
test3
+test4
+
+test1
+test2
+
test3
+test4
+
test3
+test4
+
+test1
+test2
+

aux11: +

test3
+test4
+
+test1
+test2
+
 foo
+
 bar
+

This is some inline documentation in the export list +

 a code block using bird-tracks
+ each line must begin with > (which isn't significant unless it
+ is at the beginning of the line).
+
A hidden module +
hidden :: Int -> Int
A visible module +
module Visible
nested-style doc comments +
Existential / Universal types +
data Ex a
A data-type using existential/universal types +
Constructors
forall b . C b => Ex1 b
forall b . Ex2 b
forall b . C a => Ex3 b
Ex4 (forall a. a -> a)
Type signatures with argument docs +
k
:: T () ()This argument has type T +
-> T2 Int IntThis argument has type 'T2 Int Int' +
-> T3 Bool Bool -> T4 Float FloatThis argument has type T3 Bool Bool -> T4 Float Float +
-> T5 () ()This argument has a very long description that should + hopefully cause some wrapping to happen when it is finally + rendered by Haddock in the generated HTML page. +
-> IO ()This is the result type +
This is a function with documentation for each argument +
l
:: (Int, Int, Float)takes a triple +
-> Intreturns an Int +
m
:: R
-> N1 ()one of the arguments +
-> IO Intand the return value +
This function has some arg docs +
o
:: FloatThe input float +
-> IO FloatThe output float +
A foreign import with argument docs +
A section +
A subsection +
 a literal line
+

$ a non literal line $ +

f' :: Int
a function with a prime can be referred to as f' + but f' doesn't get link'd 'f\'' +
Produced by Haddock version 2.1.0
-- cgit v1.2.3