Add the helloworld lua example code to the README

Change-Id: I29565b8b879ccac9fd8dfcdd6862fdb91cd60119
Signed-off-by: Corentin Le Gall <Nyt@clg.lorient.iot>
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

4 files changed, 154 insertions, 98 deletions

diff --git a/README.md b/README.md
index 64fcf48..2c162f8 100644
--- a/README.md
+++ b/README.md
@@ -307,7 +307,7 @@ callback let you add assertions and enrich the test.
 
 * **_AFT.testVerbStatusError(testName, api, verb, args)**
 
-    The inverse than above
+    The inverse than above.
 
 * **_AFT.testVerbResponseEquals(testName, api, verb, args, expectedResponse)**
 
@@ -316,21 +316,21 @@ callback let you add assertions and enrich the test.
 
 * **_AFT.testVerbResponseEqualsError(testName, api, verb, args, expectedResponse)**
 
-    The inverse than above
+    The inverse than above.
 
 * **_AFT.testVerbCb(testName, api, verb, args, expectedResponse, callback)**
 
-    Test that the call of a verb with a custom callback. From this callback you
+    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 doesn't need to test the response simply specify an empty LUA table.
+    If you don't need to test the response simply specify an empty LUA table.
 
 * **_AFT.testVerbCbError(testName, api, verb, args, expectedResponse, callback)**
 
     Should return success on failure.
 
-* **_AFT.testEvtReceived(testName, eventName)**
+* **_AFT.testEvtReceived(testName, 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**
@@ -339,44 +339,26 @@ callback let you add assertions and enrich the test.
     Check if an event has been correctly received. An event name use the
     application framework naming scheme: **api/event_name**.
 
-* **_AFT.testLogReceived(testName, logMsg)**
 
-    Prior to be able to check that an event has been received, you have to
-    register the event with the test framework using **_AFT.addLogToMonitor**
-    function.
-
-    Check if a log message sent by the daemon has been correctly received. A log
-    message is caracterized by its *api* and the message level *error*,
-    *warning*, *notice*, *info* or *debug*.
 
-* **_AFT.testEvtNotReceived(testName, eventName)**
+* **_AFT.testEvtNotReceived(testName, 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. An event name use the
+    Check if an event has been correctly received in time. An event name use the
     application framework naming scheme: **api/event_name**.
 
-* **_AFT.testLogNotReceived(testName, logMsg)**
-
-    Prior to be able to check that an event has been received, you have to
-    register the event with the test framework using **_AFT.addLogToMonitor**
-    function.
-
-    Check if a log message sent by the daemon has been correctly received. A log
-    message is caracterized by its *api* and the message level *error*,
-    *warning*, *notice*, *info* or *debug*.
-
 #### Binding Assert functions
 
 * **_AFT.assertVerbStatusSuccess(api, verb, args)**
 
     Simply test that the call of a verb successfully returns.
 
-* **_AFT.assertVerbStatusError(testName, api, verb, args)**
+* **_AFT.assertVerbStatusError(api, verb, args)**
 
-    The inverse than above
+    The inverse than above.
 
 * **_AFT.assertVerbResponseEquals(api, verb, args, expectedResponse)**
 
@@ -385,21 +367,21 @@ callback let you add assertions and enrich the test.
 
 * **_AFT.assertVerbResponseEqualsError(api, verb, args, expectedResponse)**
 
-    The inverse than above
+    The inverse than above.
 
 * **_AFT.assertVerbCb(api, verb, args, expectedResponse, callback)**
 
-    Test that the call of a verb with a custom callback. From this callback you
+    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 doesn't need to test the response simply specify an empty LUA table.
+    If you don't need to test the response simply specify an empty LUA table.
 
 * **_AFT.assertVerbCbError(api, verb, args, expectedResponse, callback)**
 
     Should return success on failure.
 
-* **_AFT.assertEvtReceived(eventName)**
+* **_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**
@@ -408,16 +390,7 @@ callback let you add assertions and enrich the test.
     Check if an event has been correctly received. An event name use the
     application framework naming scheme: **api/event_name**.
 
-* **_AFT.assertLogReceived(testName, logMsg)**
-
-    Prior to be able to check that an event has been received, you have to
-    register the event with the test framework using **_AFT.addLogToMonitor**
-    function.
-
-    Check if a log message sent by the daemon has been correctly received. A log
-    message is caracterized by its *api* and the message level *error*,
-    *warning*, *notice*, *info* or *debug*.
-* **_AFT.assertEvtNotReceived(eventName)**
+* **_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**
@@ -426,16 +399,6 @@ callback let you add assertions and enrich the test.
     Check if an event has been correctly received. An event name use the
     application framework naming scheme: **api/event_name**.
 
-* **_AFT.assertLogNotReceived(testName, logMsg)**
-
-    Prior to be able to check that an event has been received, you have to
-    register the event with the test framework using **_AFT.addLogToMonitor**
-    function.
-
-    Check if a log message sent by the daemon has been correctly received. A log
-    message is caracterized by its *api* and the message level *error*,
-    *warning*, *notice*, *info* or *debug*.
-
 #### Test Framework functions
 
 * **_AFT.addEventToMonitor(eventName, callback)**
@@ -462,7 +425,7 @@ callback let you add assertions and enrich the test.
 
 ##### General Assertions
 
-* **assertEquals(actual, expected)**
+* **_AFT.assertEquals(actual, expected)**
 
     Assert that two values are equal.
 
@@ -474,53 +437,53 @@ callback let you add assertions and enrich the test.
 
     LuaUnit provides other table-related assertions, see [Table assertions](http://luaunit.readthedocs.io/en/luaunit_v3_2_1/#assert-table)
 
-* **assertNotEquals(actual, expected)**
+* **_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.
 
-* **assertAlmostEquals(actual, expected, margin)**
+* **_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.
 
-* **assertNotAlmostEquals(actual, expected, margin)**
+* **_AFT.assertNotAlmostEquals(actual, expected, margin)**
 
     Assert that two floating point numbers are not almost equal.
 
 ##### Value assertions
 
-* **assertEvalToTrue(value)**
+* **_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.
 
-* **assertEvalToFalse(Value)**
+* **_AFT.assertEvalToFalse(Value)**
 
     Assert that a given value eval 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.
 
-* **assertIsTrue(value)**
+* **_AFT.assertIsTrue(value)**
 
     Assert that a given value compares to true. Lua coercion rules are applied so that values like 0, "", 1.17 all compare to true.
 
-* **assertIsFalse(value)**
+* **_AFT.assertIsFalse(value)**
 
     Assert that a given value compares to false. Lua coercion rules are applied so that only nil and false all compare to false.
 
-* **assertIsNil(value)**
+* **_AFT.assertIsNil(value)**
 
     Assert that a given value is nil .
 
-* **assertNotIsNil(value)**
+* **_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.
 
-* **assertIs(actual, expected)**
+* **_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.
 
@@ -535,7 +498,7 @@ callback let you add assertions and enrich the test.
     luaunit.assertIs(t1,t1) -- ok
     luaunit.assertIs(t1,t2) -- fail`
 
-* **assertNotIs(actual, expected)**
+* **_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.
 
@@ -544,26 +507,26 @@ callback let you add assertions and enrich the test.
 >**Note**
 >If you need to deal with value minus zero, 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)
 
-* **assertIsNaN(value)**
+* **_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.
 
-* **assertIsPlusInf(value)**
+* **_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.
 
-* **assertIsMinusInf(value)**
+* **_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.
 
-* **assertIsInf(value)**
+* **_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.
 
-* **assertIsPlusZero(value)**
+* **_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
@@ -571,7 +534,7 @@ callback let you add assertions and enrich the test.
 
     Be careful when dealing with *+0* and *-0*, see note above
 
-* **assertIsMinusZero(value)**
+* **_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
@@ -583,31 +546,31 @@ callback let you add assertions and enrich the test.
 
 Assertions related to string and patterns.
 
-* **assertStrContains(str, sub[, useRe])**
+* **_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 .
 
-* **assertStrIContains(str, sub)**
+* **_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.
 
-* **assertNotStrContains(str, sub, useRe)**
+* **_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 .
 
-* **assertNotStrIContains(str, sub)**
+* **_AFT.assertNotStrIContains(str, sub)**
 
     Assert that a string does not contain the given substring, irrespective of the case.
 
     Not that unlike assertNotStrcontains(), you can not search for a pattern.
 
-* **assertStrMatches(str, pattern[, start[, final]])**
+* **_AFT.assertStrMatches(str, pattern[, start[, final]])**
 
     Assert that a string matches the full pattern pattern.
 
@@ -617,7 +580,7 @@ Assertions related to string and patterns.
 
 Error related assertions, to verify error generation and error messages.
 
-* **assertError(func, ...)**
+* **_AFT.assertError(func, ...)**
 
     Assert that calling functions func with the arguments yields an error. If the function does not yield an error, the assertion fails.
 
@@ -628,17 +591,17 @@ Error related assertions, to verify error generation and error messages.
 >**Note**
 >When testing LuaUnit, switching from assertError() to assertErrorMsgEquals() revealed quite a few bugs!
 
-* **assertErrorMsgEquals(expectedMsg, func, ...)**
+* **_AFT.assertErrorMsgEquals(expectedMsg, func, ...)**
 
     Assert that calling 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 for the message containt with assertErrorMsgContains() .
 
-* **assertErrorMsgContains(partialMsg, func, ...)**
+* **_AFT.assertErrorMsgContains(partialMsg, func, ...)**
 
     Assert that calling 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.
 
-* **assertErrorMsgMatches(expectedPattern, func, ...)**
+* **_AFT.assertErrorMsgMatches(expectedPattern, func, ...)**
 
     Assert that calling 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 patternm the assertion fails.
 
@@ -648,41 +611,41 @@ Error related assertions, to verify error generation and error messages.
 
 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.
 
-* **assertIsNumber(value)**
+* **_AFT.assertIsNumber(value)**
 
     Assert that the argument is a number (integer or float)
 
-* **assertIsString(value)**
+* **_AFT.assertIsString(value)**
 
     Assert that the argument is a string.
 
-* **assertIsTable(value)**
+* **_AFT.assertIsTable(value)**
 
     Assert that the argument is a table.
 
-* **assertIsBoolean(value)**
+* **_AFT.assertIsBoolean(value)**
 
     Assert that the argument is a boolean.
 
-* **assertIsFunction(value)**
+* **_AFT.assertIsFunction(value)**
 
     Assert that the argument is a function.
 
-* **assertIsUserdata(value)**
+* **_AFT.assertIsUserdata(value)**
 
     Assert that the argument is a userdata.
 
-* **assertIsThread(value)**
+* **_AFT.assertIsThread(value)**
 
     Assert that the argument is a coroutine (an object with type thread ).
 
-* **assertNotIsThread(value)**
+* **_AFT.assertNotIsThread(value)**
 
     Assert that the argument is a not coroutine (an object with type thread ).
 
 ##### Table assertions
 
-* **assertItemsEquals(actual, expected)**
+* **_AFT.assertItemsEquals(actual, expected)**
 
     Assert that two tables contain the same items, irrespective of their keys.
 
@@ -692,10 +655,4 @@ The following functions all perform type checking on their argument. If the rece
 
     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.
 
-    `luaunit.assertItemsEquals( {1,{2,3},4}, {4,{3,2,},1} ) -- assertion fails because {2,3} ~= {3,2}`
-
-
-
-
-
-
+    `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/conf.d/cmake/config.cmake b/conf.d/cmake/config.cmake
index 74a1b93..ca17cec 100644
--- a/conf.d/cmake/config.cmake
+++ b/conf.d/cmake/config.cmake
@@ -193,7 +193,7 @@ set(AFB_REMPORT "1234" CACHE PATH "Default binder listening port")
 
 # Print a helper message when every thing is finished
 # ----------------------------------------------------
-set(CLOSING_MESSAGE "Typical binding launch: afb-daemon --name afbd-${PROJECT_NAME} --port=${AFB_REMPORT} --workdir=package --ldpaths=/opt/AGL/lib64/afb:lib --token=\"${AFB_TOKEN}\" --tracereq=common --verbose")
+set(CLOSING_MESSAGE "Typical binding launch: afb-daemon --name afbd-${PROJECT_NAME} --port=${AFB_REMPORT} --workdir=package --ldpaths=/opt/AGL/lib64/afb:lib --token=\"${AFB_TOKEN}\"")
 set(PACKAGE_MESSAGE "Install widget file using in the target : afm-util install ${PROJECT_NAME}.wgt")
 
 # Optional schema validator about now only XML, LUA and JSON
diff --git a/conf.d/controller/etc/aft-test.json b/conf.d/controller/etc/aft-test.json
index 8c7b7da..b3da676 100644
--- a/conf.d/controller/etc/aft-test.json
+++ b/conf.d/controller/etc/aft-test.json
@@ -4,19 +4,19 @@
     "metadata": {
         "uid": "Test",
         "version": "1.0",
-        "api": "afTest",
+        "api": "test",
         "info": "Binding made to tests other bindings",
         "require": [
             "hello"
         ]
     },
-    "testVerb": {
+    "onload": {
         "uid": "launch_all_tests",
         "info": "Launch all the tests",
         "action": "lua://AFT#_launch_test",
         "args": {
             "trace": "hello",
-            "files": "helloworld.lua"
+            "files": ["aftTest.lua","helloworld.lua"]
         }
     }
 }
diff --git a/conf.d/controller/lua.d/aftTest.lua b/conf.d/controller/lua.d/aftTest.lua
new file mode 100644
index 0000000..8e58543
--- /dev/null
+++ b/conf.d/controller/lua.d/aftTest.lua
@@ -0,0 +1,99 @@
+--[[
+    Copyright (C) 2018 "IoT.bzh"
+    Author Romain Forlot <romain.forlot@iot.bzh>
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+    NOTE: strict mode: every global variables should be prefixed by '_'
+--]]
+
+
+local corout = coroutine.create( print )
+
+_AFT.testCustom("testAssertEquals", function() _AFT.assertEquals(false, false) end)
+_AFT.testCustom("testAssertNotEquals", function()  _AFT.assertNotEquals(true,false) end)
+_AFT.testCustom("testAssertItemsEquals", function()	_AFT.assertItemsEquals({1,2,3},{3,1,2}) end)
+_AFT.testCustom("testAssertAlmostEquals", function()	_AFT.assertAlmostEquals(1.25 ,1.5,0.5) end)
+_AFT.testCustom("testAssertNotAlmostEquals", function()	_AFT.assertNotAlmostEquals(1.25,1.5,0.125) end)
+_AFT.testCustom("testAssertEvalToTrue", function()	_AFT.assertEvalToTrue(true) end)
+_AFT.testCustom("testAssertEvalToFalse", function()  _AFT.assertEvalToFalse(false) end)
+
+_AFT.testCustom("testAssertStrContains", function()  _AFT.assertStrContains("Hello I'm a string","string") end)
+_AFT.testCustom("testAssertStrContains", function()  _AFT.assertStrContains("Hello I'm a second string","second",5) end)
+
+_AFT.testCustom("testAssertStrIContains", function()  _AFT.assertStrIContains("Hello I'm another string","I'm") end)
+
+_AFT.testCustom("testAssertNotStrContains", function()  _AFT.assertNotStrContains("Hello it's me again, the other string","banana") end)
+_AFT.testCustom("testAssertNotStrContains", function()  _AFT.assertNotStrContains("Hello it's me again, the other string","banana",8) end)
+
+_AFT.testCustom("testAssertNotStrIContains", function()  _AFT.assertNotStrIContains("Hello it's not me this time !","trebuchet") end)
+
+_AFT.testCustom("testAssertStrMatches", function()  _AFT.assertStrMatches("Automotive Grade Linux","Automotive Grade Linux") end)
+_AFT.testCustom("testAssertStrMatches", function()  _AFT.assertStrMatches("Automotive Grade Linux from IoT.bzh","Automotive Grade Linux",1,22) end)
+_AFT.testCustom("testAssertError", function()  _AFT.assertError(_AFT.assertEquals(true,true)) end)
+
+_AFT.testCustom("testAssertErrorMsgEquals", function()  _AFT.assertErrorMsgEquals("attempt to call a nil value",
+																									                              _AFT.assertStrMatches("test assertErrorMsgEquals","test",1,4)) end)
+_AFT.testCustom("testAssertErrorMsgContains", function()	_AFT.assertErrorMsgContains("attempt to call",
+																									                              _AFT.assertStrMatches("test assertErrorMsgEquals","test",1,4)) end)
+_AFT.testCustom("testAssertErrorMsgMatches", function()	_AFT.assertErrorMsgMatches('attempt to call a nil value',
+																								                              _AFT.assertStrMatches("test assertErrorMsgEquals","test",1,4)) end)
+
+_AFT.testCustom("testAssertIs", function()	_AFT.assertIs('toto','to'..'to') end)
+_AFT.testCustom("testAssertNotIs", function()  _AFT.assertNotIs({1,2},{1,2}) end)
+
+_AFT.testCustom("testAssertIsNumber", function()  _AFT.assertIsNumber(23) end)
+_AFT.testCustom("testAssertIsString", function()	_AFT.assertIsString("Lapin bihan") end)
+_AFT.testCustom("testAssertIsTable", function()	_AFT.assertIsTable({1,2,3,4}) end)
+_AFT.testCustom("testAssertIsBoolean", function()	_AFT.assertIsBoolean(true) end)
+_AFT.testCustom("testAssertIsNil", function()	_AFT.assertIsNil(nil) end)
+_AFT.testCustom("testAssertIsTrue", function()	_AFT.assertIsTrue(true) end)
+_AFT.testCustom("testAssertIsFalse", function()	_AFT.assertIsFalse(false) end)
+_AFT.testCustom("testAssertIsNaN", function()	_AFT.assertIsNaN(0/0) end)
+_AFT.testCustom("testAssertIsInf", function()	_AFT.assertIsInf(1/0) end)
+_AFT.testCustom("testAssertIsPlusInf", function()	_AFT.assertIsPlusInf(1/0) end)
+_AFT.testCustom("testAssertIsMinusInf", function()	_AFT.assertIsMinusInf(-1/0) end)
+_AFT.testCustom("testAssertIsPlusZero", function()	_AFT.assertIsPlusZero(1/(1/0)) end)
+_AFT.testCustom("testAssertIsMinusZero", function()	_AFT.assertIsMinusZero(-1/(1/0)) end)
+_AFT.testCustom("testAssertIsFunction", function()	_AFT.assertIsFunction(print) end)
+_AFT.testCustom("testAssertIsThread", function()	_AFT.assertIsThread(corout) end)
+_AFT.testCustom("testAssertIsUserdata", function()  _AFT.assertIsUserdata(_AFT.context) end)
+
+_AFT.testCustom("testAssertNotIsNumber", function()  _AFT.assertNotIsNumber('a') end)
+_AFT.testCustom("testAssertNotIsString", function()	_AFT.assertNotIsString(2) end)
+_AFT.testCustom("testAssertNotIsTable", function()	_AFT.assertNotIsTable(2) end)
+_AFT.testCustom("testAssertNotIsBoolean", function()	_AFT.assertNotIsBoolean(2) end)
+_AFT.testCustom("testAssertNotIsNil", function()	_AFT.assertNotIsNil(2) end)
+_AFT.testCustom("testAssertNotIsTrue", function()	_AFT.assertNotIsTrue(false) end)
+_AFT.testCustom("testAssertNotIsFalse", function()	_AFT.assertNotIsFalse(true) end)
+_AFT.testCustom("testAssertNotIsNaN", function()	_AFT.assertNotIsNaN(1) end)
+_AFT.testCustom("testAssertNotIsInf", function()	_AFT.assertNotIsInf(2) end)
+_AFT.testCustom("testAssertNotIsPlusInf", function()	_AFT.assertNotIsPlusInf(2) end)
+_AFT.testCustom("testAssertNotIsMinusInf", function()	_AFT.assertNotIsMinusInf(2) end)
+_AFT.testCustom("testAssertNotIsPlusZero", function()	_AFT.assertNotIsPlusZero(2) end)
+_AFT.testCustom("testAssertNotIsMinusZero", function()	_AFT.assertNotIsMinusZero(2) end)
+_AFT.testCustom("testAssertNotIsFunction", function()	_AFT.assertNotIsFunction(2) end)
+_AFT.testCustom("testAssertNotIsThread", function()	_AFT.assertNotIsThread(2) end)
+_AFT.testCustom("testAssertNotIsUserdata", function()	_AFT.assertNotIsUserdata(2) end)
+
+
+function _callback(responseJ) _AFT.assertStrContains(responseJ.response, "Some String") end
+function _callbackError(responseJ) _AFT.assertStrContains(responseJ.request.info, "Ping Binder Daemon fails") end
+
+_AFT.testCustom("testAssertVerbStatusSuccess",function() _AFT.assertVerbStatusSuccess('hello', 'ping', {}) end)
+_AFT.testCustom("testAssertVerbResponseEquals",function() _AFT.assertVerbResponseEquals('hello', 'ping', {},"Some String") end)
+_AFT.testCustom("testAssertVerbCb",function() _AFT.assertVerbCb('hello', 'ping', {},_callback) end)
+_AFT.testCustom("testAssertVerbStatusError",function() _AFT.assertVerbStatusError('hello', 'pingfail', {}) end)
+_AFT.testCustom("testAssertVerbResponseEqualsError",function() _AFT.assertVerbResponseEqualsError('hello', 'pingfail', {},"Ping Binder Daemon fails") end)
+_AFT.testCustom("testAssertVerbCbError",function() _AFT.assertVerbCbError('hello', 'pingfail', {},_callbackError) end)