Docs reorganization and update

Docs reorganization and update using the latest afb-test improvments and
try to make it clearer.

Change-Id: If022cdb46364ef250361bdcd420d45b360f10a2e
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>
(cherry picked from commit 2f3654275e44f9719818a848da9a0b576d5a1b53)

12 files changed, 662 insertions, 0 deletions

diff --git a/docs/Reference/0_BindingTestFunctions.md b/docs/Reference/0_BindingTestFunctions.md
new file mode 100644
index 0000000..4ee95e0
--- /dev/null
+++ b/docs/Reference/0_BindingTestFunctions.md
@@ -0,0 +1,143 @@
+# Binding Test functions
+
+* **_AFT.testVerbStatusSuccess(testName, api, verb, args, setUp, tearDown)**
+
+    Simply test that the call of a verb successfully returns.
+
+    *setUp* and *tearDown* are functions that can be added to your test context,
+    it works just like  **_AFT.beforeEach()** and **_AFT.afterEach()**,
+    *setUp* will be ran before your *testFunction* and **_AFT.beforeEach()**
+    (if set) functions, *tearDown* will be ran after your *testFunction* and
+    **_AFT.afterEach()**  (if set) functions.
+
+    ```lua
+        _AFT.testVerbStatusSuccess('testPingSuccess','hello', 'ping', {})
+    ```
+
+* **_AFT.testVerbStatusError(testName, api, verb, args, setUp, tearDown)**
+
+    The inverse of above, test that a verb return does not succeed.
+
+    *setUp* and *tearDown* are functions that can be added to your test context,
+    it works just like  **_AFT.beforeEach()** and **_AFT.afterEach()**,
+    *setUp* will be ran before your *testFunction* and **_AFT.beforeEach()**
+    (if set) functions, *tearDown* will be ran after your *testFunction* and
+    **_AFT.afterEach()**  (if set) functions.
+
+    ```lua
+        _AFT.testVerbStatusSuccess('testPingError', 'hello', 'pingfail', {})
+    ```
+
+* **_AFT.testVerbResponseEquals(testName, api, verb, args, expectedResponse, setUp, tearDown)**
+
+    Test that the call of a verb successfully returns and that verb's response
+    is equals to the *expectedResponse*.
+
+    *setUp* and *tearDown* are functions that can be added to your test context,
+    it works just like  **_AFT.beforeEach()** and **_AFT.afterEach()**, *setUp*
+    will be ran before your *testFunction* and **_AFT.beforeEach()** (if set)
+    functions, *tearDown* will be ran after your *testFunction* and
+    **_AFT.afterEach()**  (if set) functions.
+
+    ```lua
+        _AFT.testVerbResponseEquals('testPingSuccess','hello', 'ping', {}, "Some String")
+    ```
+
+* **_AFT.testVerbResponseEqualsError(testName, api, verb, args, expectedResponse, setUp, tearDown)**
+
+    The inverse of above.
+
+    *setUp* and *tearDown* are functions that can be added to your test context, it works
+    just like  **_AFT.beforeEach()** and **_AFT.afterEach()**, *setUp* will be ran
+    before your *testFunction* and **_AFT.beforeEach()** (if set) functions,
+    *tearDown* will be ran after your *testFunction* and **_AFT.afterEach()**  (if
+    set) functions.
+
+    ```lua
+        _AFT.testVerbResponseEqualsError('testPingError', 'hello', 'pingfail', {}, "Ping Binder Daemon fails")
+    ```
+
+* **_AFT.testVerbCb(testName, api, verb, args, expectedResponse, callback, setUp, tearDown)**
+
+    Test the call of a verb with a custom callback. From this callback you
+    will need to make some assertions on what you need (verb JSON return object
+    content mainly).
+
+    If you don't need to test the response simply specify an empty LUA table.
+
+    *setUp* and *tearDown* are functions that can be added to your test context, it works
+    just like  **_AFT.beforeEach()** and **_AFT.afterEach()**, *setUp* will be ran
+    before your *testFunction* and **_AFT.beforeEach()** (if set) functions,
+    *tearDown* will be ran after your *testFunction* and **_AFT.afterEach()**  (if
+    set) functions.
+
+    ```lua
+    function _callback(responseJ)
+        _AFT.assertStrContains(responseJ.response, "Some String")
+    end
+    _AFT.testVerbCb('testPingSuccess','hello', 'ping', {}, _callback)
+    ```
+
+* **_AFT.testVerbCbError(testName, api, verb, args, expectedResponse, callback, setUp, tearDown)**
+
+    Should return success on failure.
+
+    *setUp* and *tearDown* are functions that can be added to your test context, it works
+    just like  **_AFT.beforeEach()** and **_AFT.afterEach()**, *setUp* will be ran
+    before your *testFunction* and **_AFT.beforeEach()** (if set) functions,
+    *tearDown* will be ran after your *testFunction* and **_AFT.afterEach()**  (if
+    set) functions.
+
+    ```lua
+    function _callbackError(responseJ)
+            _AFT.assertStrContains(responseJ.request.info, "Ping Binder Daemon fails")
+    end
+
+    _AFT.testVerbCbError('testPingError', 'hello', 'pingfail', {}, _callbackError)
+    ```
+
+* **_AFT.testEvtReceived(testName, eventName, timeout, setUp, tearDown)**
+
+    Prior to be able to check that an event has been received, you have to
+    register the event with the test framework using **_AFT.addEventToMonitor**
+    function.
+
+    Check if an event has been correctly received in time (timeout in µs). An event
+    name use the application framework naming scheme: **api/event_name**.
+
+    ```lua
+        _AFT.testEvtReceived("testEvent", "hello/anEvent",300000)
+    ```
+
+* **_AFT.testEvtNotReceived(testName, eventName, timeout, setUp, tearDown)**
+
+    Prior to be able to check that an event has not been received, you have to
+    register the event with the test framework using **_AFT.addEventToMonitor**
+    function.
+
+    Check if an event has not been correctly received in time (timeout in µs). An
+    event name use the application framework naming scheme: **api/event_name**.
+
+    ```lua
+        _AFT.testEvtNotReceived("testEventCb", "hello/anotherEvent",300000)
+    ```
+
+* **_AFT.testGrpEvtReceived(testName, eventGrp, timeout, setUp, tearDown)**
+
+    Prior to be able to check that a group of events (a table of events) has been
+    received, you have to register the events with the test framework using
+    **_AFT.addEventToMonitor** function.
+
+    The table has to have this format:
+    ```lua
+    eventGrp = {["api/event_name_1"]=1, ["api/event_name_2"]=2, ["api/event_name_3"]=5}
+    ```
+    As you can see in the table, event names are table keys and the value stored are
+    the number of time that the events have to be received.
+
+    Check if events has been correctly received in time (timeout in µs). An
+    event name use the application framework naming scheme: **api/event_name**.
+
+    ```lua
+    _AFT.testEvtGrpReceived("TestEventGroupReceived",{["hello/anEvent"]=3,["hello/anotherEvent"]=1}, 300000)
+    ```
\ No newline at end of file
diff --git a/docs/Reference/1_BindingAssertFunctions.md b/docs/Reference/1_BindingAssertFunctions.md
new file mode 100644
index 0000000..b05f73b
--- /dev/null
+++ b/docs/Reference/1_BindingAssertFunctions.md
@@ -0,0 +1,75 @@
+# Binding Assert functions
+
+* **_AFT.assertVerbStatusSuccess(api, verb, args)**
+
+    Simply test that the call of a verb successfully returns.
+
+* **_AFT.assertVerbStatusError(api, verb, args)**
+
+    The inverse of above. Expects that the verbs fails.
+
+* **_AFT.assertVerbResponseEquals(api, verb, args, expectedResponse)**
+
+    Test that the call of a verb successfully returns and that verb's response
+    is equal to the *expectedResponse*.
+
+* **_AFT.assertVerbResponseEqualsError(api, verb, args, expectedResponse)**
+
+    The inverse of above. Expect an error on the verb call either on the verb or on the expected
+    response.
+
+* **_AFT.assertVerbCb(api, verb, args, expectedResponse, callback)**
+
+    Test the call of a verb with a custom callback. From this callback you
+    will need to make some assertions on what you need (verb JSON return object
+    content mainly).
+
+    If you don't need to test the response simply specify an empty LUA table.
+
+    ```lua
+    function _callback(responseJ)
+        _AFT.assertStrContains(responseJ.response, "Some String")
+    end
+
+    _AFT.describe("myTestLabel", function()
+      _AFT.testVerbCb('testPingSuccess','hello', 'ping', {}, _callback)
+    end)
+    ```
+
+* **_AFT.assertVerbCbError(api, verb, args, expectedResponse, callback)**
+
+    Should return success on failure.
+
+* **_AFT.assertEvtReceived(eventName, timeout)**
+
+    Prior to be able to check that an event has been received, you have to
+    register the event with the test framework using **_AFT.addEventToMonitor**
+    function.
+
+    Check if an event has been correctly received in timeout specified (timeout in µs).
+    An event name use the application framework naming scheme: **api/event_name**.
+
+* **_AFT.assertEvtNotReceived(eventName, timeout)**
+
+    Prior to be able to check that an event has been received, you have to
+    register the event with the test framework using **_AFT.addEventToMonitor**
+    function.
+
+    Check if an event has been correctly received in time (timeout in µs).
+    An event name use the application framework naming scheme: **api/event_name**.
+
+* **_AFT.assertGrpEvtReceived(eventGrp, timeout)**
+
+    Prior to be able to check that a group of events (a table of event) has been
+    received, you have to register the events with the test framework using
+    **_AFT.addEventToMonitor** function.
+
+    The table has to have this format:
+    ```lua
+    eventGrp = {["api/event_name_1"]=1,["api/event_name_2"]=2,["api/event_name_3"]=5}
+    ```
+    As you can see, in the table, event names are table keys and the value stored are
+    the number of time that the events have to be received.
+
+    Check if events has been correctly received in timeout specified (timeout in µs).
+    An event name use the application framework naming scheme: **api/event_name**.
\ No newline at end of file
diff --git a/docs/Reference/2_TestFrameworkFunctions.md b/docs/Reference/2_TestFrameworkFunctions.md
new file mode 100644
index 0000000..c952e3f
--- /dev/null
+++ b/docs/Reference/2_TestFrameworkFunctions.md
@@ -0,0 +1,59 @@
+# Test Framework functions
+
+* **_AFT.addEventToMonitor(eventName, callback)**
+
+    Add a binding event in the test framework to be able to assert its reception
+    . You'll need to add as many events as you expect to receive. You could also
+    specify a callback to test in more details the event received, like the attached
+    data. The callback will happens after the assertion that it has been received so
+    you can work on data that the event eventually carry.
+
+* **_AFT.setJunitFile(filePath)**
+
+    Set the *JUnit* file path. When *JUnit* is set as the output type for the
+    test framework.
+
+* **_AFT.setBeforeEach(function)**
+
+    Set the **_AFT.beforeEach()** function which is used to run the specified
+    *function* before each tests.
+
+* **_AFT.setAfterEach(function)**
+
+    Set the **_AFT.afterEach()** function which is used to run the specified
+    *function* after each tests.
+
+* **_AFT.setBeforeAll(function)**
+
+    Set the **_AFT.beforeAll()** function which is used to run the specified
+    *function* before all tests. If the given function is successful it has
+    to return 0 else it will return an error.
+
+* **_AFT.setAfterAll(function)**
+
+    Set the **_AFT.afterAll()** function which is used to run the specified
+    *function* after all tests. If the given function is successful it has
+    to return 0 else it will return an error.
+
+* **_AFT.describe(testName, testFunction, setUp, tearDown)**
+
+    Describe a manually written test. *testFunction* will be given the name
+    provided by *testName* and will be tested.
+
+    *setUp* and *tearDown* are functions that can be added to your context,
+    it works just like  **_AFT.beforeEach()** and **_AFT.afterEach()**,
+    *setUp* will be ran before your *testFunction* and **_AFT.beforeEach()**
+    (if set) functions, *tearDown* will be ran after your *testFunction* and
+    **_AFT.afterEach()**  (if set) functions.
+
+* **_AFT.setBefore(testName, beforeTestFunction)**
+    Set a function to be ran at the beginning of the given *testName* function.
+
+    ```lua
+    _AFT.testVerbStatusSuccess('testPingSuccess','hello', 'ping', {})
+    _AFT.setBefore("testPingSuccess",function() print("~~~~~ Begin testPingSuccess ~~~~~") end)
+    _AFT.setAfter("testPingSuccess",function() print("~~~~~ End testPingSuccess ~~~~~") end)
+    ```
+
+* **_AFT.setBefore(testName, beforeTestFunction)**
+    Set a function to be ran at the end of the given *testName* function.
\ No newline at end of file
diff --git a/docs/Reference/Introduction.md b/docs/Reference/Introduction.md
new file mode 100644
index 0000000..8de5a15
--- /dev/null
+++ b/docs/Reference/Introduction.md
@@ -0,0 +1,10 @@
+# References
+
+Follow this section to know which functions are available !!
+
+Section's Table of content :
+
+* [Binding test functions](0_BindingTestFunctions.html)
+* [Binding assert functions](1_BindingAssertFunctions.html)
+* [Test framework functions](2_TestFrameworkFunctions.html)
+* [LUAUnit assertion functions](LuaUnitAssertionFunctions/Introduction.html)
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/0_GeneralAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/0_GeneralAssertions.md
new file mode 100644
index 0000000..6282755
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/0_GeneralAssertions.md
@@ -0,0 +1,63 @@
+# General Assertions
+
+* **_AFT.assertEquals(actual, expected)**
+
+    Assert that two values are equal.
+
+    For tables, the comparison is a deep comparison :
+
+  * number of elements must be the same
+  * tables must contain the same keys
+  * each key must contain the same values. The values are also compared recursively with deep comparison.
+
+    LuaUnit provides other table-related assertions, see [Table assertions](http://luaunit.readthedocs.io/en/luaunit_v3_2_1/#assert-table)
+
+    ```lua
+    _AFT.assertEquals("string", "string")
+    ```
+
+* **_AFT.assertNotEquals(actual, expected)**
+
+    Assert that two values are different. The assertion fails if the two values are identical.
+
+    It also uses table deep comparison.
+    
+    ```lua
+    _AFT.assertNotEquals("string", "Another string")
+    ```
+
+* **_AFT.assertAlmostEquals(actual, expected, margin)**
+
+    Assert that two floating point numbers are almost equal.
+
+    When comparing floating point numbers, strict equality does not work.
+    Computer arithmetic is so that an operation that mathematically yields
+    1.00000000 might yield 0.999999999999 in lua . That’s why you need an
+    almost equals comparison, where you specify the error margin.
+    
+    ```lua
+    -- convert pi/6 radian to 30 degree
+    pi_div_6_deg_calculated = math.deg(math.pi/6)
+    pi_div_6_deg_expected = 30
+
+    -- convert pi/3 radian to 60 degree
+    pi_div_3_deg_calculated = math.deg(math.pi/3)
+    pi_div_3_deg_expected = 60
+
+    -- check absolute error: it is not constant
+    print( (pi_div_6_deg_expected - pi_div_6_deg_calculated) / lu.EPS ) -- prints: 16
+    print( (pi_div_3_deg_expected - pi_div_3_deg_calculated) / lu.EPS ) -- prints: 32
+
+    -- Better use relative error:
+    print( ( (pi_div_6_deg_expected - pi_div_6_deg_calculated) / pi_div_6_deg_expected) / lu.EPS ) -- prints: 0.53333
+    print( ( (pi_div_3_deg_expected - pi_div_3_deg_calculated) / pi_div_3_deg_expected) / lu.EPS ) -- prints: 0.53333
+
+    -- relative error is constant. Assertion can take the form of:
+    assertAlmostEquals( (pi_div_6_deg_expected - pi_div_6_deg_calculated) / pi_div_6_deg_expected, lu.EPS )
+    assertAlmostEquals( (pi_div_3_deg_expected - pi_div_3_deg_calculated) / pi_div_3_deg_expected, lu.EPS )
+    ```
+
+* **_AFT.assertNotAlmostEquals(actual, expected, margin)**
+
+    Assert that two floating point numbers are not almost equal.
+    
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/1_ValueAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/1_ValueAssertions.md
new file mode 100644
index 0000000..3769b62
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/1_ValueAssertions.md
@@ -0,0 +1,79 @@
+# Value assertions
+
+* **_AFT.assertEvalToTrue(value)**
+
+    Assert that a given value evals to true. Lua coercion rules are applied so
+    that values like 0,"",1.17 succeed in this assertion. If provided, extra_msg
+    is a string which will be printed along with the failure message.
+
+    ```lua
+    _AFT.assertEvalToTrue(3 == 1+2)
+    ```
+
+* **_AFT.assertEvalToFalse(Value)**
+
+    Assert that a given value evals to *false*. Lua coercion rules are applied so
+    that *nil* and *false* succeed in this assertion. If provided, extra_msg is a
+    string which will be printed along with the failure message.
+
+    ```lua
+    _AFT.assertEvalToFalse(3 == 2)
+    ```
+
+* **_AFT.assertIsTrue(value)**
+
+    Assert that a given value evals to true. Lua coercion rules are applied so
+    that values like 0, "", 1.17 all compare to true.
+
+    ```lua
+    _AFT.assertIsTrue(3 == 1+2)
+    ```
+
+* **_AFT.assertIsFalse(value)**
+
+    Assert that a given value evals to false. Lua coercion rules are applied so
+    that only nil and false all compare to false.
+
+    ```lua
+    _AFT.assertIsFalse(3 == 2)
+    ```
+
+* **_AFT.assertIsNil(value)**
+
+    Assert that a given value is nil.
+
+    ```lua
+    var = nil
+    _AFT.assertIsNil(var)
+    ```
+
+* **_AFT.assertNotIsNil(value)**
+
+    Assert that a given value is not *nil* . Lua coercion rules are applied
+    so that values like ``0``, ``""``, ``false`` all validate the assertion.
+    If provided, *extra_msg* is a string which will be printed along with the
+    failure message.
+
+* **_AFT.assertIs(actual, expected)**
+
+    Assert that two variables are identical. For string, numbers, boolean and
+    for nil, this gives the same result as assertEquals() . For the other types,
+    identity means that the two variables refer to the same object.
+
+    Example :
+
+    ```lua
+    `s1='toto'
+    s2='to'..'to'
+    t1={1,2}
+    t2={1,2}
+    _AFT.assertIs(s1,s1) -- ok
+    _AFT.assertIs(s1,s2) -- ok
+    _AFT.assertIs(t1,t1) -- ok
+    _AFT.assertIs(t1,t2) -- fail`
+    ```
+
+* **_AFT.assertNotIs(actual, expected)**
+
+    Assert that two variables are not identical, in the sense that they do not
+    refer to the same value. See assertIs() for more details.
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/2_ScientificAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/2_ScientificAssertions.md
new file mode 100644
index 0000000..a9ce270
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/2_ScientificAssertions.md
@@ -0,0 +1,48 @@
+# Scientific assertions
+
+>**Note**
+>If you need to deal with value *minus zero* (-0), be very careful because Lua versions
+are inconsistent on how they treat the >syntax -0 : it creates either a plus
+zero or a minus zero. Multiplying or dividing 0 by -1 also yields inconsistent >
+results. The reliable way to create the -0 value is : minusZero = -1 / (1/0).
+
+* **_AFT.assertIsNaN(value)**
+    Assert that a given number is a *NaN* (Not a Number), according to the
+    definition of IEEE-754_ . If provided, *extra_msg* is a string which will
+    be printed along with the failure message.
+
+* **_AFT.assertIsPlusInf(value)**
+
+    Assert that a given number is *plus infinity*, according to the definition of
+    IEEE-754_. If provided, *extra_msg* is a string which will be printed along
+    with the failure message.
+
+* **_AFT.assertIsMinusInf(value)**
+
+    Assert that a given number is *minus infinity*, according to the definition of
+    IEEE-754_. If provided, *extra_msg* is a string which will be printed along
+    with the failure message.
+
+* **_AFT.assertIsInf(value)**
+
+    Assert that a given number is *infinity* (either positive or negative),
+    according to the definition of IEEE-754_. If provided, *extra_msg* is a string
+    which will be printed along with the failure message.
+
+* **_AFT.assertIsPlusZero(value)**
+
+    Assert that a given number is *+0*, according to the definition of IEEE-754_.
+    The verification is done by dividing by the provided number and verifying
+    that it yields *infinity* . If provided, *extra_msg* is a string which will
+    be printed along with the failure message.
+
+    Be careful when dealing with *+0* and *-0*, see note above
+
+* **_AFT.assertIsMinusZero(value)**
+
+    Assert that a given number is *-0*, according to the definition of IEEE-754_.
+    The verification is done by dividing by the provided number and verifying that
+    it yields *minus infinity* . If provided, *extra_msg* is a string which will
+    be printed along with the failure message.
+
+    Be careful when dealing with *+0* and *-0*
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/3_StringAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/3_StringAssertions.md
new file mode 100644
index 0000000..929ec14
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/3_StringAssertions.md
@@ -0,0 +1,38 @@
+# String assertions
+
+Assertions related to string and patterns.
+
+* **_AFT.assertStrContains(str, sub[, useRe])**
+
+    Assert that a string contains the given substring or pattern.
+
+    By default, substring is searched in the string. If useRe is provided and is
+    true, sub is treated as a pattern which is searched inside the string str.
+
+* **_AFT.assertStrIContains(str, sub)**
+
+    Assert that a string contains the given substring, irrespective of the case.
+
+    Not that unlike assertStrcontains(), you can not search for a pattern.
+
+* **_AFT.assertNotStrContains(str, sub, useRe)**
+
+    Assert that a string does not contain a given substring or pattern.
+
+    By default, substring is searched in the string. If useRe is provided and is
+    true, sub is treated as a pattern which is searched inside the string str.
+
+* **_AFT.assertNotStrIContains(str, sub)**
+
+    Assert that a string does not contain the given substring, irrespective of
+    the case.
+
+    Note that unlike assertNotStrcontains(), you can not search for a pattern.
+
+* **_AFT.assertStrMatches(str, pattern[, start[, final]])**
+
+    Assert that a string matches the full pattern pattern.
+
+    If start and final are not provided or are nil, the pattern must match the
+    full string, from start to end. The functions allows to specify the expected
+    start and end position of the pattern in the string.
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/4_ErrorAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/4_ErrorAssertions.md
new file mode 100644
index 0000000..13d381f
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/4_ErrorAssertions.md
@@ -0,0 +1,43 @@
+# Error assertions
+
+Error related assertions, to verify error generation and error messages.
+
+* **_AFT.assertError(func, ...)**
+
+    Assert that calls to the function **func** with the arguments yields an error. If the function does
+    not yield an error, the assertion fails.
+
+    Note that the error message itself is not checked, which means that this function does not
+    distinguish between the legitimate error that you expect and another error that might be
+    triggered by mistake.
+
+    The next functions provide a better approach to error testing, by checking explicitly the error
+    message content.
+
+>**Note**
+>When testing LuaUnit, switching from assertError() to assertErrorMsgEquals() revealed quite a few bugs!
+
+* **_AFT.assertErrorMsgEquals(expectedMsg, func, ...)**
+
+    Assert that calls to the function **func** will generate exactly the given error message. If the
+    function does not yield an error, or if the error message is not identical, the assertion fails.
+
+    Be careful when using this function that error messages usually contain the file name and line
+    number information of where the error was generated. This is usually inconvenient. To ignore the
+    filename and line number information, you can either use a pattern with assertErrorMsgMatches()
+    or simply check if the message contains a string with assertErrorMsgContains() .
+
+* **_AFT.assertErrorMsgContains(partialMsg, func, ...)**
+
+    Assert that calls to the function **func** will generate an error message containing partialMsg.
+    If the function does not yield an error, or if the expected message is not contained in the
+    error message, the assertion fails.
+
+* **_AFT.assertErrorMsgMatches(expectedPattern, func, ...)**
+
+    Assert that calls to the function **func** will generate an error message matching expectedPattern.
+    If the function does not yield an error, or if the error message does not match the provided
+    pattern the assertion fails.
+
+    Note that matching is done from the start to the end of the error message. Be sure to escape
+    magic all magic characters with % (like -+.?\*) .
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/5_TypeAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/5_TypeAssertions.md
new file mode 100644
index 0000000..d96ef6b
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/5_TypeAssertions.md
@@ -0,0 +1,72 @@
+# Type assertions
+
+The following functions all perform type checking on their argument. If the
+received value is not of the right type, the failure message will contain the
+expected type, the received type and the received value to help you identify
+better the problem.
+
+* **_AFT.assertIsNumber(value)**
+
+    Assert that the argument is a number (integer or float)
+    
+    ```lua
+    _AFT.assertIsNumber(1)
+    ```
+
+* **_AFT.assertIsString(value)**
+
+    Assert that the argument is a string.
+    
+    ```lua
+    _AFT.assertIsString("string")
+    ```
+
+* **_AFT.assertIsTable(value)**
+
+    Assert that the argument is a table.
+    
+    ```lua
+    _AFT.assertIsTable({key = "value"})
+    ```
+
+* **_AFT.assertIsBoolean(value)**
+
+    Assert that the argument is a boolean.
+    
+    ```lua
+    _AFT.assertIsBoolean(false)
+    ```
+
+* **_AFT.assertIsFunction(value)**
+
+    Assert that the argument is a function.
+    
+    ```lua
+    _AFT.assertIsFunction(function() print("HELLO WORLD!") end)
+    ```
+
+* **_AFT.assertIsUserdata(value)**
+
+    Assert that the argument is a userdata.
+    
+    ```lua
+    _AFT.assertIsUserdata(someCvariableImportedAsUserDataInLua)
+    ```
+
+* **_AFT.assertIsThread(value)**
+
+    Assert that the argument is a coroutine (an object with type thread ).
+    
+    ```lua
+    local corout = coroutine.create( print )
+
+    _AFT.assertIsUserdata(corout)
+    ```
+
+* **_AFT.assertNotIsThread(value)**
+
+    Assert that the argument is a not coroutine (an object with type thread ).
+    
+    ```lua
+    _AFT.assertNotIsThread(2)
+    ```
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/6_TableAssertions.md b/docs/Reference/LuaUnitAssertionFunctions/6_TableAssertions.md
new file mode 100644
index 0000000..8d29988
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/6_TableAssertions.md
@@ -0,0 +1,19 @@
+# Table assertions
+
+* **_AFT.assertItemsEquals(actual, expected)**
+
+    Assert that two tables contain the same items, irrespective of their keys.
+
+    This function is practical for example if you want to compare two lists but
+    where items are not in the same order:
+
+    ```lua
+    luaunit.assertItemsEquals( {1,2,3}, {3,2,1} ) -- assertion succeeds
+    ```
+    The comparison is not recursive on the items: if any of the items are tables,
+    they are compared using table equality (like as in assertEquals() ), where the
+    key matters.
+
+    ```lua
+    luaunit.assertItemsEquals( {1,{2,3},4}, {4,{3,2,},1} ) -- assertion fails because {2,3} ~= {3,2}
+    ```
\ No newline at end of file
diff --git a/docs/Reference/LuaUnitAssertionFunctions/Introduction.md b/docs/Reference/LuaUnitAssertionFunctions/Introduction.md
new file mode 100644
index 0000000..2bdf05c
--- /dev/null
+++ b/docs/Reference/LuaUnitAssertionFunctions/Introduction.md
@@ -0,0 +1,13 @@
+# LuaUnit Assertion Functions
+
+Follow this section to know which luaUnit assertion functions are available !!
+
+Section's Table of content :
+
+* [General Assertions](0_GeneralAssertions.html)
+* [Value Assertions](1_ValueAssertions.html)
+* [Scientific Assertions](2_ScientificAssertions.html)
+* [String Assertions](3_StringAssertions.html)
+* [Error Assertions](4_ErrorAssertions.html)
+* [Type Assertions](5_TypeAssertions.html)
+* [Table Assertions](6_TableAssertions.html)
\ No newline at end of file