Îõ³h$*Q(8Ü      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ Safe-Inferred£\]^_`abc Safe-Inferred-3?ý HUnitÝWhen an assertion is evaluated, it will output a message if and only if the assertion fails.ÀTest cases are composed of a sequence of one or more assertions. HUnit4Unconditionally signals that a failure has occurred. HUnitŸAsserts that the specified actual value is equal to the expected value. The output message will contain the prefix, the expected value, and the actual value.)If the prefix is the empty string (i.e., ""Ò), then the prefix is omitted and only the expected and actual values are output. HUnitPerforms a single test case. HUnit6A message that is displayed with the assertion failure HUnitThe message prefixHUnitThe expected valueHUnitThe actual value HUnit0an assertion to be made during the test case run     Safe-Inferred-?ñHUnitComposed into s.HUnitéUniquely describes the location of a test within a test hierarchy. Node order is from test case to root.HUnitþReport generator for reporting problems that have occurred during a test run. Problems may be errors or assertion failures.HUnit7Report generator for reporting the start of a test run.HUnit¦Keeps track of the remaining tests and the results of the performed tests. As each test is performed, the path is removed and the counts are updated as appropriate.HUnitÞA data structure that hold the results of tests that have been performed up until this point.%HUnit&Provides a way to convert data into a Test or set of Test.'HUnitÃThe basic structure used to create an annotated tree of test cases.(HUnit)A single, independent test case composed.)HUnit A set of Test*s sharing the same level in the hierarchy.*HUnit+A name or description for a subtree of the Tests.+HUnitÍUsed to signify that a data type can be converted to an assertion predicate.-HUnit:The result of an assertion that hasn't been evaluated yet.+Most test cases follow the following steps:  Do some processing or an action.Assert certain conditions.,However, this flow is not always suitable. AssertionPredicateÒ allows for additional steps to be inserted without the initial action to be affected by side effects. Additionally, clean-up can be done before the test case has a chance to end. A potential work flow is: Write data to a file.+Read data from a file, evaluate conditions.Clean up the file.ËAssert that the side effects of the read operation meet certain conditions.7Assert that the conditions evaluated in step 2 are met..HUnitA specialized form of 0 to handle lists.0HUnit0Allows the extension of the assertion mechanism. Since an   can be a sequence of  Assertions and IOå actions, there is a fair amount of flexibility of what can be achieved. As a rule, the resulting  Assertion should be the body of a ( or part of a TestCaseÄ; it should not be used to assert multiple, independent conditions.7If more complex arrangements of assertions are needed, 's and % should be used.2HUnit+Asserts that the specified condition holds.3HUnitÑSignals an assertion failure if a non-empty message (i.e., a message other than "" ) is passed.4HUnit:Asserts that the condition obtained from the specified + holds.5HUnitúAsserts that the specified actual value is equal to the expected value (with the expected value on the left-hand side).6HUnitøAsserts that the specified actual value is equal to the expected value (with the actual value on the left-hand side).7HUnitÚCreates a test case resulting from asserting the condition obtained from the specified +.8HUnit“Shorthand for a test case that asserts equality (with the expected value on the left-hand side, and the actual value on the right-hand side).9HUnit“Shorthand for a test case that asserts equality (with the actual value on the left-hand side, and the expected value on the right-hand side).:HUnit"Creates a test from the specified %-, with the specified label attached to it.Since ' is Testable6, this can be used as a shorthand way of attaching a * to one or more tests.;HUnitDetermines the paths for all (s in a tree of Tests.<HUnitCounts the number of (s in a tree of Tests.=HUnit9Performs a test run with the specified report generators.ÑThis handles the actual running of the tests. Most developers will want to use HUnit.Text.runTestTTÍ instead. A developer could use this function to execute tests via another IO system, such as a GUI, or to output the results in a different manner (e.g., upload XML-formatted results to a webservice).†Note that the counts in a start report do not include the test case being started, whereas the counts in a problem report do include the test case just finished. The principle is that the counts are sampled only between test case executions. As a result, the number of test case successes always equals the difference of test cases tried and the sum of test case errors and failures. 2HUnit4The message that is displayed if the assertion failsHUnit The condition3HUnit8The message that is displayed with the assertion failure4HUnit5A value of which the asserted condition is predicatedHUnit2A message that is displayed if the assertion fails5HUnitThe expected valueHUnitThe actual value6HUnitThe actual valueHUnitThe expected value7HUnit5A value of which the asserted condition is predicatedHUnit+A message that is displayed on test failure8HUnitThe expected valueHUnitThe actual value9HUnitThe actual valueHUnitThe expected value=HUnit'report generator for the test run startHUnit/report generator for errors during the test runHUnit;report generator for assertion failures during the test runHUnitthe test to be executed,  !"#$%&'()*+,-./0123456789:;<=,'()*89:7 2 3 56401./-+,%& !"#$;<=415161718191:0 Safe-InferredâRHUnit,Simplifies the input string by interpreting \r and \bÈ characters specially so that the result string has the same final (or terminal¡, pun intended) appearance as would the input string when written to a terminal that overwrites character positions following carriage returns and backspaces.RR Safe-Inferred'ÇSHUnit+As the general text-based test controller (W–) executes a test, it reports each test case start, error, and failure by constructing a string and passing it to the function embodied in a Sç. A report string is known as a "line", although it includes no line terminator; the function in a S¡ is responsible for terminating lines appropriately. Besides the line, the function receives a flag indicating the intended "persistence" of the line: dÈ indicates that the line should be part of the final overall report; eß indicates that the line merely indicates progress of the test execution. Each progress line shows the current values of the cumulative test execution counts; a final, persistent line shows the final count values.The SË function is also passed, and returns, an arbitrary state value (called st4 here). The initial state value is given in the S!; the final value is returned by W.UHUnit)Two reporting schemes are defined here. putTextToHandle* writes report lines to a given handle. V8 accumulates persistent lines for return as a whole by W.putTextToHandleú writes persistent lines to the given handle, following each by a newline character. In addition, if the given flag is True©, it writes progress lines to the handle as well. A progress line is written with no line termination, so that it can be overwritten by the next report line. As overwriting involves writing carriage return and blank characters, its proper effect is usually only obtained on terminal devices.VHUnitÇAccumulates persistent lines (dropping progess lines) for return by W1. The accumulated lines are represented by a f (g -> g)ß function whose first argument is the string to be appended to the accumulated report lines.WHUnitîExecutes a test, processing each report line according to the given reporting scheme. The reporting scheme's state is threaded through calls to the reporting scheme's function and finally returned, along with final count values.XHUnit+Converts test execution counts to a string.YHUnit…Converts a test case path to a string, separating adjacent elements by the colon (':'). An element of the path is quoted (as with h') when there is potential ambiguity.ZHUnit¿Provides the "standard" text-based test controller. Reporting is made to standard error, and progress reports are included. For possible programmatic use, the final counts are returned.ÅThe "TT" in the name suggests "Text-based reporting to the Terminal".[HUnitConvenience wrapper for Z. Simply runs Z) and then exits back to the OS, using i, if there were no errors or failures, or j if there were. For example: Ætests :: Test tests = ... main :: IO () main = runTestTTAndExit testsUHUnitWrite progress lines to handle? STUVWXYZ[ STUVWYXZ[ Safe-Inferred'ÿ5  $#!"%&'*()+,-./0123456789:;<=STUVWXYZ[ë      !!"#$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWWXYZ[\]^_`abcdefghighjklmknoklpkqrkqsô$HUnit-1.6.1.0-LrUCEYpDzI7K2xRubhR8TsTest.HUnit.LangTest.HUnit.BaseTest.HUnit.TerminalTest.HUnit.Text Paths_HUnit Test.HUnitResultSuccessFailureError FailureReasonReasonExpectedButGot HUnitFailure Assertion assertFailure assertEqualformatFailureReasonperformTestCase$fExceptionHUnitFailure $fEqResult $fShowResult$fEqHUnitFailure$fShowHUnitFailure$fEqFailureReason$fShowFailureReasonNodeListItemLabelPath ReportProblem ReportStartStatepathcountsCountscasestriederrorsfailuresTestabletestTestTestCaseTestList TestLabelAssertionPredicableassertionPredicateAssertionPredicateListAssertable listAssert Assertableassert assertBool assertString@?@=?@?=~?~=?~?=~: testCasePaths testCaseCount performTest$fAssertableIO$fAssertableBool$fAssertable()$fListAssertableChar$fAssertable[]$fAssertionPredicableIO$fAssertionPredicableBool $fShowTest $fTestable[] $fTestableIO$fTestableTest $fEqState $fShowState $fReadState$fEqNode $fShowNode $fReadNode $fEqCounts $fShowCounts $fReadCountsterminalAppearancePutTextputTextToHandleputTextToShowS runTestText showCountsshowPath runTestTTrunTestTTAndExitversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameghc-prim GHC.TypesTrueFalsebaseGHC.ShowShowSGHC.BaseStringshow System.Exit exitSuccess exitFailure