start to support

- usbd host
- osal

some global define
#define TUSB_CFG_HOST_CONTROLLER_NUM
#define TUSB_CFG_HOST_DEVICE_MAX
#define TUSB_CFG_CONFIGURATION_MAX

rename & refractor HID type structure & enum

use CException to test asssertion library
add test for hid_host_keyboard with usbd configure get & osal queue get stubs
update test for assertion library
refractor ASSERT_STATUS in assertion library
update tusb_error_t values
rename usb basic type & enum in tusb_types.h and std_descriptors.h

5 files changed, 341 insertions, 58 deletions

diff --git a/tests/project.yml b/tests/project.yml
index ec4c6cb42..be644f147 100644
--- a/tests/project.yml
+++ b/tests/project.yml
@@ -6,7 +6,7 @@
 # This sample, therefore, only demonstrates running a collection of unit tests.
 
 :project:
-  :use_exceptions: FALSE
+  :use_exceptions: TRUE
   :use_test_preprocessor: TRUE
   :use_auxiliary_dependencies: TRUE
   :use_deep_dependencies: TRUE
@@ -69,9 +69,11 @@
   :mock_prefix: mock_
   :when_no_prototypes: :warn
   :enforce_strict_ordering: TRUE
+#  :callback_include_count: FALSE
   :plugins:
     - :ignore
     - :callback
+    - :array
   :treat_as:
     uint8:    HEX8
     uint16:   HEX16
diff --git a/tests/test/host/test_hid_host_keyboard.c b/tests/test/host/test_hid_host_keyboard.c
index e02c18a84..fa639abbe 100644
--- a/tests/test/host/test_hid_host_keyboard.c
+++ b/tests/test/host/test_hid_host_keyboard.c
@@ -36,21 +36,127 @@
  */
 
 #include "unity.h"
-#include "hid.h"
+#include "errors.h"
 #include "hid_host.h"
+#include "mock_osal.h"
+#include "mock_usbd_host.h"
+
+tusb_device_info_t usbh_device_pool [2];
+
+tusb_keyboard_report_t sample_key[2] =
+{
+    {
+        .modifier = TUSB_KEYBOARD_MODIFIER_LEFTCTRL,
+        .keycode = {TUSB_KEYBOARD_KEYCODE_a}
+    },
+    {
+        .modifier = TUSB_KEYBOARD_MODIFIER_RIGHTALT,
+        .keycode = {TUSB_KEYBOARD_KEYCODE_z}
+    }
+};
+
+tusb_handle_configure_t config_hdl;
+tusb_keyboard_report_t report;
+tusb_configure_info_t *p_cfg_info;
 
 void setUp(void)
 {
+  config_hdl = 1; // deviceID = 0 ; Configure = 1
+  memset(&report, 0, sizeof(tusb_keyboard_report_t));
+  p_cfg_info = NULL;
+
+  usbh_device_pool[0].configuration[0].classes.hid_keyboard.pipe_in = 1;
+  usbh_device_pool[0].configuration[0].classes.hid_keyboard.qid = 1;
+
+  usbh_device_pool[0].configuration[1].classes.hid_keyboard.pipe_in = 0;
+  usbh_device_pool[0].configuration[1].classes.hid_keyboard.qid = 0;
 }
 
 void tearDown(void)
 {
 }
 
-void test_keyboard_get_invalid_parameter()
+tusb_error_t queue_get_stub(osal_queue_id_t qid, uint32_t *data, osal_timeout_t msec, int num_call)
 {
-  tusb_interface_keyboard_handle_t handle;
-  tusb_keyboard_report_t report;
-  TEST_ASSERT_FALSE (tusb_host_keyboard_get(NULL, &report));
-  TEST_ASSERT_FALSE (tusb_host_keyboard_get(&handle, NULL));
+  memcpy(data, (uint32_t*)(&sample_key[num_call/2]) + (num_call%2), 4);
+  return TUSB_ERROR_NONE;
 }
+
+tusb_error_t get_configure_class_not_support_stub(tusb_handle_configure_t configure_hdl, tusb_configure_info_t **pp_configure_info, int num_call)
+{
+  (*pp_configure_info) = &(usbh_device_pool[0].configuration[1]);
+  return TUSB_ERROR_NONE;
+}
+
+tusb_error_t get_configure_stub(tusb_handle_configure_t configure_hdl, tusb_configure_info_t **pp_configure_info, int num_call)
+{
+  (*pp_configure_info) = &(usbh_device_pool[0].configuration[0]);
+  return TUSB_ERROR_NONE;
+}
+
+void test_keyboard_get_invalid_para()
+{
+  usbh_configure_info_get_IgnoreAndReturn(TUSB_ERROR_INVALID_PARA);
+  TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_keyboard_get(config_hdl, NULL));
+  TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_keyboard_get(config_hdl, &report));
+}
+
+void test_keyboard_get_class_not_supported()
+{
+  usbh_configure_info_get_StubWithCallback(get_configure_class_not_support_stub);
+
+  TEST_ASSERT_EQUAL(TUSB_ERROR_CLASS_DEVICE_DONT_SUPPORT, tusbh_keyboard_get(config_hdl, &report));
+}
+
+void test_keyboard_get_from_empty_queue()
+{
+  usbh_configure_info_get_StubWithCallback(get_configure_stub);
+  osal_queue_get_IgnoreAndReturn(TUSB_ERROR_OSAL_TIMEOUT);
+//  osal_queue_get_ExpectAndReturn( usbh_device_pool[0].configuration[0].classes.hid_keyboard.qid, );
+
+  TEST_ASSERT_EQUAL(TUSB_ERROR_OSAL_TIMEOUT, tusbh_keyboard_get(config_hdl, &report));
+}
+
+void test_keyboard_get_ok()
+{
+  usbh_configure_info_get_StubWithCallback(get_configure_stub);
+  osal_queue_get_StubWithCallback(queue_get_stub);
+
+  TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_keyboard_get(config_hdl, &report));
+  TEST_ASSERT_EQUAL_MEMORY(&sample_key[0], &report, sizeof(tusb_keyboard_report_t));
+
+  TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_keyboard_get(config_hdl, &report));
+  TEST_ASSERT_EQUAL_MEMORY(&sample_key[1], &report, sizeof(tusb_keyboard_report_t));
+}
+
+#if 0
+void test_keyboard_open_invalid_para()
+{
+  tusb_handle_keyboard_t keyboard_handle;
+
+  TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_keyboard_open(TUSB_CFG_HOST_DEVICE_MAX, 1, &keyboard_handle) );
+  TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_keyboard_open(0, 0, &keyboard_handle) );
+  TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_keyboard_open(0, TUSB_CFG_CONFIGURATION_MAX+1, &keyboard_handle) );
+  TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_keyboard_open(0, 1, NULL) );
+}
+
+void test_keyboard_open_succeed()
+{
+  tusb_handle_keyboard_t keyboard_handle = 0;
+
+  TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_keyboard_open(0, 1, &keyboard_handle));
+  TEST_ASSERT_TRUE( 0 != keyboard_handle);
+}
+
+void test_keyboard_callback__()
+{
+  TEST_IGNORE();
+  tusb_handle_device_t device_handle = __LINE__;
+  tusb_handle_configure_t configure_handle = __LINE__;
+  tusb_handle_interface_t interface_handle = __LINE__;
+  uint32_t configure_flags = BIT_(TUSB_CLASS_HID);
+  tusbh_usbd_device_mounted_cb_ExpectWithArray(TUSB_ERROR_NONE, device_handle, &configure_flags, 1, 1);
+}
+#endif
+
+
diff --git a/tests/test/host/test_usbd_host.c b/tests/test/host/test_usbd_host.c
new file mode 100644
index 000000000..a1555f175
--- /dev/null
+++ b/tests/test/host/test_usbd_host.c
@@ -0,0 +1,52 @@
+/*
+ * test_usbd_host.c
+ *
+ *  Created on: Jan 21, 2013
+ *      Author: hathach
+ */
+
+/*
+ * Software License Agreement (BSD License)
+ * Copyright (c) 2012, hathach (tinyusb.net)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the tiny usb stack.
+ */
+
+#include "unity.h"
+#include "usbd_host.h"
+
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
+void test_()
+{
+  // TEST_IGNORE();
+}
diff --git a/tests/test/support/tusb_config.h b/tests/test/support/tusb_config.h
index 52e2506cf..04d29d849 100644
--- a/tests/test/support/tusb_config.h
+++ b/tests/test/support/tusb_config.h
@@ -56,6 +56,9 @@
 #endif
 
 #define TUSB_CFG_HOST
+#define TUSB_CFG_HOST_CONTROLLER_NUM 2
+#define TUSB_CFG_HOST_DEVICE_MAX 2
+#define TUSB_CFG_CONFIGURATION_MAX 2
 
 /// Enable Device Support
 //#define TUSB_CFG_DEVICE
diff --git a/tests/test/test_assertion.c b/tests/test/test_assertion.c
index a289f2bdf..1f6288def 100644
--- a/tests/test/test_assertion.c
+++ b/tests/test/test_assertion.c
@@ -35,14 +35,21 @@
  * This file is part of the tiny usb stack.
  */
 
+#define _TEST_ASSERT_
+
 #include <stdint.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include "unity.h"
+#include "CException.h"
 #include "common/assertion.h"
+#include "errors.h"
+
+CEXCEPTION_T e;
 
 void setUp(void)
 {
+  e = 0;
 }
 
 void tearDown(void)
@@ -50,23 +57,81 @@ void tearDown(void)
 }
 
 //--------------------------------------------------------------------+
+// Error Status
+//--------------------------------------------------------------------+
+void test_assert_status(void)
+{
+  Try
+  {
+    ASSERT_STATUS(TUSB_ERROR_NONE);
+    ASSERT_STATUS(TUSB_ERROR_INVALID_PARA);
+  }
+  Catch (e)
+  {
+  }
+}
+
+//--------------------------------------------------------------------+
 // Logical
 //--------------------------------------------------------------------+
 void test_assert_logical_true(void)
 {
-  ASSERT      (true  , (void)0 );
-  ASSERT_TRUE (true  , (void)0 );
-
-  ASSERT_TRUE (false , (void)0 );
-  TEST_FAIL();
+  Try
+  {
+    ASSERT       (true , __LINE__);
+    ASSERT_TRUE  (true , __LINE__);
+    ASSERT_TRUE  (false, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
 void test_assert_logical_false(void)
 {
-  ASSERT_FALSE(false , (void)0 );
-  ASSERT_FALSE(true  , (void)0 );
+  Try
+  {
+    ASSERT_FALSE (false, __LINE__);
+    ASSERT_FALSE (true , 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
+}
+//--------------------------------------------------------------------+
+// Pointer
+//--------------------------------------------------------------------+
+void test_assert_pointer_not_null(void)
+{
+  uint32_t n;
+
+  Try
+  {
+    ASSERT_PTR_NOT_NULL(&n, __LINE__);
+    ASSERT_PTR(&n, __LINE__);
+    ASSERT_PTR(NULL, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
+}
+
+void test_assert_pointer_null(void)
+{
+  uint32_t n;
 
-  TEST_FAIL();
+  Try
+  {
+    ASSERT_PTR_NULL(NULL, __LINE__);
+    ASSERT_PTR_NULL(&n, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
 //--------------------------------------------------------------------+
@@ -74,37 +139,67 @@ void test_assert_logical_false(void)
 //--------------------------------------------------------------------+
 void test_assert_int_eqal(void)
 {
-  ASSERT_INT       (1, 1, (void) 0);
-  ASSERT_INT_EQUAL (1, 1, (void) 0);
-
-  uint32_t x = 0;
-  uint32_t y = 0;
-  ASSERT_INT (x++, y++, (void) 0); // test side effect
-  TEST_ASSERT_EQUAL(1, x);
-  TEST_ASSERT_EQUAL(1, y);
+  Try
+  {
+    ASSERT_INT       (1, 1, __LINE__);
+    ASSERT_INT_EQUAL (1, 1, __LINE__);
 
-  ASSERT_INT(0, 1, (void) 0);
+    // test side effect
+    uint32_t x = 0;
+    uint32_t y = 0;
+    ASSERT_INT (x++, y++, __LINE__);
+    TEST_ASSERT_EQUAL(1, x);
+    TEST_ASSERT_EQUAL(1, y);
 
-  TEST_FAIL();
+    ASSERT_INT (1, 0, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
-void test_assert_int_within_succeed(void)
+void test_assert_int_within(void)
 {
-  ASSERT_INT_WITHIN (1, 5, 3, (void) 0);
-  ASSERT_INT_WITHIN (1, 5, 1, (void) 0);
-  ASSERT_INT_WITHIN (1, 5, 5, (void) 0);
+  Try
+  {
+    ASSERT_INT_WITHIN (1, 5, 3, __LINE__);
+    ASSERT_INT_WITHIN (1, 5, 1, __LINE__);
+    ASSERT_INT_WITHIN (1, 5, 5, __LINE__);
+
+    ASSERT_INT_WITHIN (1, 5, 0, 0);
+    ASSERT_INT_WITHIN (1, 5, 10, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
-void test_assert_int_within_less(void)
+void test_assert_int_within_greater(void)
 {
-  ASSERT_INT_WITHIN (1, 5, 0, (void) 0);
-  TEST_FAIL();
+  Try
+  {
+    ASSERT_INT_WITHIN (1, 5, 10, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
+
 }
 
-void test_assert_int_within_greater(void)
+void test_assert_int_within_less(void)
 {
-  ASSERT_INT_WITHIN (1, 5, 10, (void) 0);
-  TEST_FAIL();
+  Try
+  {
+    ASSERT_INT_WITHIN (1, 5, 0, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
+
 }
 
 //--------------------------------------------------------------------+
@@ -112,54 +207,79 @@ void test_assert_int_within_greater(void)
 //--------------------------------------------------------------------+
 void test_assert_hex_equal(void)
 {
-  ASSERT_HEX       (0xffee, 0xffee, (void) 0);
-  ASSERT_HEX_EQUAL (0xffee, 0xffee, (void) 0);
-
-  uint32_t x = 0xf0f0;
-  uint32_t y = 0xf0f0;
-  ASSERT_HEX (x++, y++, (void) 0); // test side effect
-  TEST_ASSERT_EQUAL(0xf0f1, x);
-  TEST_ASSERT_EQUAL(0xf0f1, y);
+  Try
+  {
+    ASSERT_HEX       (0xffee, 0xffee, __LINE__);
+    ASSERT_HEX_EQUAL (0xffee, 0xffee, __LINE__);
 
-  ASSERT_HEX(0x1234, 0x4321, (void) 0);
+    // test side effect
+    uint32_t x = 0xf0f0;
+    uint32_t y = 0xf0f0;
+    ASSERT_HEX (x++, y++, __LINE__);
+    TEST_ASSERT_EQUAL(0xf0f1, x);
+    TEST_ASSERT_EQUAL(0xf0f1, y);
 
-  TEST_FAIL();
+    ASSERT_HEX(0x1234, 0x4321, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
-void test_assert_hex_within_succeed(void)
+void test_assert_hex_within(void)
 {
-  ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xff11, (void) 0);
-  ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xff00, (void) 0);
-  ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xffff, (void) 0);
+  Try
+  {
+    ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xff11, __LINE__);
+    ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xff00, __LINE__);
+    ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xffff, __LINE__);
+  }
+  Catch (e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
 void test_assert_hex_within_less(void)
 {
-  ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xeeee, (void) 0);
-  TEST_FAIL();
+  Try
+  {
+    ASSERT_HEX_WITHIN (0xff00, 0xffff, 0xeeee, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
 void test_assert_hex_within_greater(void)
 {
-  ASSERT_HEX_WITHIN (0xff00, 0xffff, 0x1eeee, (void) 0);
-  TEST_FAIL();
+  Try
+  {
+    ASSERT_HEX_WITHIN (0xff00, 0xffff, 0x1eeee, 0);
+  }
+  Catch(e)
+  {
+    TEST_ASSERT_EQUAL(0, e);
+  }
 }
 
 //--------------------------------------------------------------------+
-// HEX
+// BIN
 //--------------------------------------------------------------------+
 void test_assert_bin_equal(void)
 {
-//  ASSERT_HEX       (0xffee, 0xffee, (void) 0);
-//  ASSERT_HEX_EQUAL (0xffee, 0xffee, (void) 0);
+//  ASSERT_HEX       (0xffee, 0xffee, __LINE__);
+//  ASSERT_HEX_EQUAL (0xffee, 0xffee, __LINE__);
 //
 //  uint32_t x = 0xf0f0;
 //  uint32_t y = 0xf0f0;
-//  ASSERT_HEX (x++, y++, (void) 0); // test side effect
+//  ASSERT_HEX (x++, y++, __LINE__); // test side effect
 //  TEST_ASSERT_EQUAL(0xf0f1, x);
 //  TEST_ASSERT_EQUAL(0xf0f1, y);
 //
-//  ASSERT_HEX(0x1234, 0x4321, (void) 0);
+//  ASSERT_HEX(0x1234, 0x4321, __LINE__);
 
   TEST_IGNORE();
 }