interface Test.HUnit where {
infix   1 Test.HUnit.Base.@?;
infix   1 Test.HUnit.Base.@=?;
infix   1 Test.HUnit.Base.@?=;
infix   1 Test.HUnit.Base.~?;
infix   1 Test.HUnit.Base.~=?;
infix   1 Test.HUnit.Base.~?=;
infixr  0 Test.HUnit.Base.~:;

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;

{-# NEED #-}
instance Test.HUnit.Base.ListAssertable Prelude.Char;

{-# NEED #-}
instance Test.HUnit.Base.Assertable ();

{-# NEED #-}
instance Test.HUnit.Base.Assertable Prelude.Bool;

{-# NEED #-}
instance (Test.HUnit.Base.ListAssertable a) => Test.HUnit.Base.Assertable [a];

{-# NEED #-}
instance (Test.HUnit.Base.Assertable a) => Test.HUnit.Base.Assertable (NHC.Internal.IO a);

{-# NEED #-}
instance Test.HUnit.Base.AssertionPredicable Prelude.Bool;

{-# NEED #-}
instance (Test.HUnit.Base.AssertionPredicable a) => Test.HUnit.Base.AssertionPredicable (NHC.Internal.IO a);

{-# NEED #-}
instance (Test.HUnit.Base.Testable a) => Test.HUnit.Base.Testable [a];

{-# NEED #-}
instance (Test.HUnit.Base.Assertable a) => Test.HUnit.Base.Testable (NHC.Internal.IO a);

{-# NEED #-}
instance Test.HUnit.Base.Testable Test.HUnit.Base.Test;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.RealFrac (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Read Test.HUnit.Base.Node;

{-# NEED #-}
instance Prelude.Read Test.HUnit.Base.State;

{-# NEED #-}
instance Prelude.Read Test.HUnit.Base.Counts;

{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Eq IO.Handle;

{-# NEED #-}
instance Prelude.Eq Test.HUnit.Base.Node;

{-# NEED #-}
instance Prelude.Eq Test.HUnit.Base.State;

{-# NEED #-}
instance Prelude.Eq Test.HUnit.Base.Counts;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Show IO.Handle;

{-# NEED #-}
instance Prelude.Show Test.HUnit.Base.Node;

{-# NEED #-}
instance Prelude.Show Test.HUnit.Base.State;

{-# NEED #-}
instance Prelude.Show Test.HUnit.Base.Counts;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);

{-# NEED #-}
instance Prelude.Show Test.HUnit.Base.Test;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Test.HUnit.Text
{-# NEED putTextToHandle #-}
putTextToHandle{-# 2 #-}::(IO.Handle -> (Prelude.Bool -> (Test.HUnit.Text.PutText Prelude.Int)));
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface ! Test.HUnit.Text
{-# NEED putTextToShowS #-}
putTextToShowS{-# 0 #-}::(Test.HUnit.Text.PutText Prelude.ShowS);

{-# NEED runTestText #-}
runTestText{-# 2 #-}::((Test.HUnit.Text.PutText a) -> (Test.HUnit.Base.Test -> (NHC.Internal.IO (Test.HUnit.Base.Counts,a))));

{-# NEED {PutText PutText} #-}
data PutText a
  = PutText (Prelude.String -> (Prelude.Bool -> (a -> (NHC.Internal.IO a)))) a;

{-# NEED showCounts #-}
showCounts{-# 1 #-}::(Test.HUnit.Base.Counts -> Prelude.String);

{-# NEED showPath #-}
showPath{-# 1 #-}::(Test.HUnit.Base.Path -> Prelude.String);

{-# NEED runTestTT #-}
runTestTT{-# 1 #-}::(Test.HUnit.Base.Test -> (NHC.Internal.IO Test.HUnit.Base.Counts));
interface ! Test.HUnit.Lang
{-# NEED assertFailure #-}
assertFailure{-# 1 #-}::(Prelude.String -> Test.HUnit.Lang.Assertion);
interface ! Test.HUnit.Base
{-# NEED assertBool #-}
assertBool{-# 2 #-}::(Prelude.String -> (Prelude.Bool -> Test.HUnit.Lang.Assertion));

{-# NEED assertString #-}
assertString{-# 1 #-}::(Prelude.String -> Test.HUnit.Lang.Assertion);

{-# NEED assertEqual #-}
assertEqual{-# 3 #-}::(Prelude.Eq a,Prelude.Show a) => (Prelude.String -> (a -> (a -> Test.HUnit.Lang.Assertion)));

{-# NEED {ListAssertable listAssert} #-}
class ListAssertable a where {
  listAssert{-# 1 #-}::([a] -> Test.HUnit.Lang.Assertion);
};

{-# NEED (@?) #-}
(@?){-# 2 #-}::(Test.HUnit.Base.AssertionPredicable a) => (a -> (Prelude.String -> Test.HUnit.Lang.Assertion));

{-# NEED (@=?) #-}
(@=?){-# 2 #-}::(Prelude.Eq a,Prelude.Show a) => (a -> (a -> Test.HUnit.Lang.Assertion));

{-# NEED (@?=) #-}
(@?=){-# 2 #-}::(Prelude.Eq a,Prelude.Show a) => (a -> (a -> Test.HUnit.Lang.Assertion));

{-# NEED testCaseCount #-}
testCaseCount{-# 1 #-}::(Test.HUnit.Base.Test -> Prelude.Int);

{-# NEED testCasePaths #-}
testCasePaths{-# 1 #-}::(Test.HUnit.Base.Test -> [Test.HUnit.Base.Path]);

{-# NEED {Assertable assert} #-}
class Assertable a where {
  assert{-# 1 #-}::(a -> Test.HUnit.Lang.Assertion);
};

{-# NEED (~?) #-}
(~?){-# 2 #-}::(Test.HUnit.Base.AssertionPredicable a) => (a -> (Prelude.String -> Test.HUnit.Base.Test));

{-# NEED {AssertionPredicable assertionPredicate} #-}
class AssertionPredicable a where {
  assertionPredicate{-# 1 #-}::(a -> Test.HUnit.Base.AssertionPredicate);
};

{-# NEED AssertionPredicate #-}
type {-# 1 #-} AssertionPredicate = (NHC.Internal.IO Prelude.Bool);

{-# NEED (~=?) #-}
(~=?){-# 2 #-}::(Prelude.Eq a,Prelude.Show a) => (a -> (a -> Test.HUnit.Base.Test));

{-# NEED (~?=) #-}
(~?=){-# 2 #-}::(Prelude.Eq a,Prelude.Show a) => (a -> (a -> Test.HUnit.Base.Test));

{-# NEED (~:) #-}
(~:){-# 2 #-}::(Test.HUnit.Base.Testable a) => (Prelude.String -> (a -> Test.HUnit.Base.Test));

{-# NEED {Testable test} #-}
class Testable a where {
  test{-# 1 #-}::(a -> Test.HUnit.Base.Test);
};

{-# NEED performTest #-}
performTest{-# 5 #-}::((Test.HUnit.Base.ReportStart a) -> ((Test.HUnit.Base.ReportProblem a) -> ((Test.HUnit.Base.ReportProblem a) -> (a -> (Test.HUnit.Base.Test -> (NHC.Internal.IO (Test.HUnit.Base.Counts,a)))))));

{-# NEED {Test TestCase TestList TestLabel} #-}
data Test
  = TestCase Test.HUnit.Lang.Assertion
  | TestList [Test.HUnit.Base.Test]
  | TestLabel Prelude.String Test.HUnit.Base.Test;
interface ! Test.HUnit.Lang
{-# NEED Assertion #-}
type {-# 1 #-} Assertion = (NHC.Internal.IO ());
interface ! Test.HUnit.Base
{-# NEED ReportProblem #-}
type {-# 4 #-} ReportProblem a = (Prelude.String -> (State -> (a -> (NHC.Internal.IO a))));

{-# NEED ReportStart #-}
type {-# 3 #-} ReportStart a = (State -> (a -> (NHC.Internal.IO a)));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Test.HUnit.Base
{-# NEED {State State path counts} #-}
data State
  = State {Test.HUnit.Base.path :: Test.HUnit.Base.Path} {Test.HUnit.Base.counts :: Test.HUnit.Base.Counts};

{-# NEED {Counts Counts cases tried errors failures} #-}
data Counts
  = Counts {Test.HUnit.Base.cases :: Prelude.Int} {Test.HUnit.Base.tried :: Prelude.Int} {Test.HUnit.Base.errors :: Prelude.Int} {Test.HUnit.Base.failures :: Prelude.Int};

{-# NEED Path #-}
type {-# 2 #-} Path = [Node];

{-# NEED {Node ListItem Label} #-}
data Node
  = ListItem Prelude.Int
  | Label Prelude.String;
}