!1102 fix:设置LOSCFG_PLATFORM_HWI_WITH_ARG为1后，编译失败问题修复

Merge pull request !1102 from zhangkt/master

OAT.xml

@@ -23,6 +23,7 @@
         <policylist>
             <policy name="projectPolicy" desc="">
                 <policyitem type="copyright" name="Huawei Technologies Co., Ltd. All rights reserved." path=".*" desc="original liteos copyright"/>
+                <policyitem type="copyright" name="Hunan OpenValley Digital Industry Development Co., Ltd." path=".*" desc="Developed By OpenValley Digital Co., Ltd."/>
                 <policyitem type="license" name="BSD-3-Clause" path=".*" desc="Liteos kernel use bsd3 license"/>
                 <policyitem type="license" name="BSD-3-Clause" path=".*" desc="Liteos kernel use bsd3 license"/>
             </policy>

arch/arm/common/los_common_interrupt.c

@@ -105,10 +105,6 @@ BOOL OsHwiIsCreated(UINT32 index)
 #endif
 
 #if (LOSCFG_PLATFORM_HWI_WITH_ARG == 1)
-typedef struct {
-    HWI_PROC_FUNC pfnHandler;
-    VOID *pParm;
-} HWI_HANDLER_FUNC;
 
 /* *
  * @ingroup los_hwi

arch/arm/common/los_common_interrupt.h

@@ -63,6 +63,11 @@ extern UINT32 g_intCount;
 #endif
 
 #if (LOSCFG_PLATFORM_HWI_WITH_ARG == 1)
+typedef struct {
+    HWI_PROC_FUNC pfnHandler;
+    VOID *pParm;
+} HWI_HANDLER_FUNC;
+
 /* *
  * @ingroup los_arch_interrupt
  * Set interrupt vector table.

arch/arm/cortex-m7/iar/BUILD.gn

@@ -0,0 +1,47 @@
+# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2024 Huawei Device Co., Ltd. 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. Neither the name of the copyright holder nor the names of its contributors may be used
+#    to endorse or promote products derived from this software without specific prior written
+#    permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "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 COPYRIGHT HOLDER OR
+# CONTRIBUTORS 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.
+
+import("//kernel/liteos_m/liteos.gni")
+
+module_name = "arch"
+kernel_module(module_name) {
+  sources = [
+    "los_context.c",
+    "los_dispatch.S",
+    "los_exc.S",
+    "los_interrupt.c",
+    "los_mpu.c",
+    "los_timer.c",
+  ]
+  configs += [ "$LITEOSTOPDIR:warn_config" ]
+}
+
+config("public") {
+  include_dirs = [ "." ]
+}

arch/csky/common/los_common_interrupt.c

@@ -155,10 +155,6 @@ UINT32 ArchIntCurIrqNum(VOID)
 }
 
 #if (LOSCFG_PLATFORM_HWI_WITH_ARG == 1)
-typedef struct {
-    HWI_PROC_FUNC pfnHandler;
-    VOID *pParm;
-} HWI_HANDLER_FUNC;
 
 /* *
  * @ingroup los_hwi

arch/csky/common/los_common_interrupt.h

@@ -63,6 +63,11 @@ extern volatile UINT32 g_intCount;
 #endif
 
 #if (LOSCFG_PLATFORM_HWI_WITH_ARG == 1)
+typedef struct {
+    HWI_PROC_FUNC pfnHandler;
+    VOID *pParm;
+} HWI_HANDLER_FUNC;
+
 /* *
  * @ingroup los_arch_interrupt
  * Set interrupt vector table.

arch/xtensa/common/los_common_interrupt.c

@@ -137,10 +137,6 @@ UINT32 ArchIntCurIrqNum(VOID)
 }
 
 #if (LOSCFG_PLATFORM_HWI_WITH_ARG == 1)
-typedef struct {
-    HWI_PROC_FUNC pfnHandler;
-    VOID *pParm;
-} HWI_HANDLER_FUNC;
 
 /* *
  * @ingroup los_hwi

arch/xtensa/common/los_common_interrupt.h

@@ -63,6 +63,11 @@ extern UINT32 g_intCount;
 #endif
 
 #if (LOSCFG_PLATFORM_HWI_WITH_ARG == 1)
+typedef struct {
+    HWI_PROC_FUNC pfnHandler;
+    VOID *pParm;
+} HWI_HANDLER_FUNC;
+
 /* *
  * @ingroup los_arch_interrupt
  * Set interrupt vector table.

bundle.json

@@ -27,9 +27,6 @@
     "component": {
         "name": "liteos_m",
         "subsystem": "kernel",
-        "syscap": [
-            "SystemCapability.Kernel.Liteos-M"
-        ],
         "features": [],
         "adapted_system_type": [
             "mini"

kernel/include/los_queue.h

@@ -39,6 +39,7 @@
 
 #include "los_list.h"
 #include "los_config.h"
+#include "los_task.h"
 
 #ifdef __cplusplus
 #if __cplusplus
@@ -487,6 +488,50 @@ extern UINT32 LOS_QueueReadCopy(UINT32 queueID,
                                 UINT32 *bufferSize,
                                 UINT32 timeOut);
 
+/**
+ * @ingroup los_queue
+ * @brief Read a queue in interrupt service routine.
+ *
+ * @par Description:
+ * This API is used to read data in a specified queue, and store the obtained data to the address specified
+ * by bufferAddr. The address and the size of the data to be read are defined by users. 
+ * It is safe to use this API from within an interrupt service routine.
+ * @attention
+ * <ul>
+ * <li>The specific queue should be created firstly.</li>
+ * <li>Queue reading adopts the fist in first out (FIFO) mode. The data that is first stored in the queue is read
+ * first.</li>
+ * <li>This API read a queue in unblocking modes.</li>
+ * <li>bufferAddr stores the obtained data.</li>
+ * <li>This API cannot be called before the kernel is initialized.</li>
+ * </ul>
+ *
+ * @param queueID        [IN]     Queue ID created by LOS_QueueCreate. The value range is
+ * [1,LOSCFG_BASE_IPC_QUEUE_LIMIT].
+ * @param bufferAddr     [OUT]    Starting address that stores the obtained data. The starting address must not be
+ * null.
+ * @param bufferSize     [IN/OUT] Where to maintain the buffer expected-size before read, and the real-size after read.
+ *
+ * @retval   #LOS_OK                              The queue is successfully read.
+ * @retval   #LOS_ERRNO_QUEUE_INVALID             The handle of the queue that is being read is invalid.
+ * @retval   #LOS_ERRNO_QUEUE_READ_PTR_NULL       The pointer passed in during queue reading is null.
+ * @retval   #LOS_ERRNO_QUEUE_READSIZE_ISZERO     The buffer size passed in during queue reading is 0.
+ * @retval   #LOS_ERRNO_QUEUE_NOT_CREATE          The queue to be read is not created.
+ * @retval   #LOS_ERRNO_QUEUE_ISEMPTY             No resource is in the queue that is being read when the time for
+ * waiting to processing the queue expires.
+ * @retval   #LOS_ERRNO_QUEUE_READ_SIZE_TOO_SMALL The buffer size passed in during queue reading is less than
+ * the queue size.
+ * @par Dependency:
+ * <ul><li>los_queue.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_QueueWriteCopy | LOS_QueueCreate
+ */
+STATIC INLINE  UINT32 LOS_QueueReadCopyIsr(UINT32 queueID,
+                                           VOID *bufferAddr,
+                                           UINT32 *bufferSize)
+{
+    return LOS_QueueReadCopy(queueID, bufferAddr, bufferSize, LOS_NO_WAIT);
+}
+
 /**
  * @ingroup los_queue
  * @brief Write data into a queue.
@@ -533,6 +578,47 @@ extern UINT32 LOS_QueueWriteCopy(UINT32 queueID,
                                  UINT32 bufferSize,
                                  UINT32 timeOut);
 
+/**
+ * @ingroup los_queue
+ * @brief Write data into a queue in interrupt service routine.
+ *
+ * @par Description:
+ * This API is used to write the data of the size specified by bufferSize and stored at the address specified by
+ * bufferAddr into a queue.It is safe to use this API from within an interrupt service routine.
+ * @attention
+ * <ul>
+ * <li>The specific queue should be created firstly.</li>
+ * <li>This API write data into a queue in unblocking modes.</li>
+ * <li>This API cannot be called before the kernel is initialized.</li>
+ * <li>The data to be written is of the size specified by bufferSize and is stored at the address specified by
+ * BufferAddr.</li>
+ * </ul>
+ *
+ * @param queueID        [IN]        Queue ID created by LOS_QueueCreate. The value range is
+ * [1,LOSCFG_BASE_IPC_QUEUE_LIMIT].
+ * @param bufferAddr     [IN]        Starting address that stores the data to be written.The starting address must
+ * not be null.
+ * @param bufferSize     [IN]        Passed-in buffer size. The value range is [1,USHRT_MAX - sizeof(UINT32)].
+ *
+ * @retval   #LOS_OK                                 The data is successfully written into the queue.
+ * @retval   #LOS_ERRNO_QUEUE_INVALID                The queue handle passed in during queue writing is invalid.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_PTR_NULL         The pointer passed in during queue writing is null.
+ * @retval   #LOS_ERRNO_QUEUE_WRITESIZE_ISZERO       The buffer size passed in during queue writing is 0.
+ * @retval   #LOS_ERRNO_QUEUE_NOT_CREATE             The queue into which the data is written is not created.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_SIZE_TOO_BIG     The buffer size passed in during queue writing is bigger than
+ * the queue size.
+ * @retval   #LOS_ERRNO_QUEUE_ISFULL                 No free node is available during queue writing.
+ * @par Dependency:
+ * <ul><li>los_queue.h: the header file that contains the API declaration.</li></ul>
+ * @see LOS_QueueReadCopy | LOS_QueueCreate
+ */
+STATIC INLINE UINT32 LOS_QueueWriteCopyIsr(UINT32 queueID,
+                                           VOID *bufferAddr,
+                                           UINT32 bufferSize)
+{
+    return LOS_QueueWriteCopy(queueID, bufferAddr, bufferSize, LOS_NO_WAIT);
+}
+
 /**
  * @ingroup los_queue
  * @brief Read a queue.
@@ -582,6 +668,50 @@ extern UINT32 LOS_QueueRead(UINT32 queueID,
                             UINT32 bufferSize,
                             UINT32 timeOut);
 
+/**
+ * @ingroup los_queue
+ * @brief Read a queue in interrupt service routine.
+ *
+ * @par Description:
+ * This API is used to read the address of data in a specified queue, and store it to the address specified by
+ * bufferAddr.It is safe to use this API from within an interrupt service routine.
+ * @attention
+ * <ul>
+ * <li>The specific queue should be created firstly.</li>
+ * <li>Queue reading adopts the fist in first out (FIFO) mode. The data that is first stored in the queue is
+ * read first.</li>
+ * <li>This API read a queue in unblocking modes.</li>
+ * <li>bufferAddr stores the obtained data address.</li>
+ * <li>This API cannot be called before the kernel is initialized.</li>
+ * <li>The bufferSize is not really used in LOS_QueueRead, because the interface is only used to
+ * obtain the address of data.</li>
+ * <li>The buffer which the bufferAddr pointing to must be greater than or equal to 4 bytes.</li>
+ * </ul>
+ *
+ * @param queueID        [IN]        Queue ID created by LOS_QueueCreate. The value range is
+ * [1,LOSCFG_BASE_IPC_QUEUE_LIMIT].
+ * @param bufferAddr     [OUT]       Starting address that stores the obtained data. The starting address must
+ * not be null.
+ * @param bufferSize     [IN]        Passed-in buffer size, which must not be 0. The value range is [1,0xffffffff].
+ *
+ * @retval   #LOS_OK                               The queue is successfully read.
+ * @retval   #LOS_ERRNO_QUEUE_INVALID              The handle of the queue that is being read is invalid.
+ * @retval   #LOS_ERRNO_QUEUE_READ_PTR_NULL        The pointer passed in during queue reading is null.
+ * @retval   #LOS_ERRNO_QUEUE_READSIZE_ISZERO      The buffer size passed in during queue reading is 0.
+ * @retval   #LOS_ERRNO_QUEUE_NOT_CREATE           The queue to be read is not created.
+ * @retval   #LOS_ERRNO_QUEUE_ISEMPTY              No resource is in the queue that is being read when the time for
+ * waiting to processing the queue expires.
+ * @par Dependency:
+ * <ul><li>los_queue.h: The header file that contains the API declaration.</li></ul>
+ * @see LOS_QueueWrite | LOS_QueueCreate
+ */
+STATIC INLINE UINT32 LOS_QueueReadIsr(UINT32 queueID,
+                                      VOID *bufferAddr,
+                                      UINT32 bufferSize)
+{
+    return LOS_QueueRead(queueID, bufferAddr, bufferSize, LOS_NO_WAIT);
+}
+
 /**
  * @ingroup los_queue
  * @brief Write data into a queue.
@@ -629,6 +759,49 @@ extern UINT32 LOS_QueueWrite(UINT32 queueID,
                              UINT32 bufferSize,
                              UINT32 timeOut);
 
+/**
+ * @ingroup los_queue
+ * @brief Write data into a queue in interrupt service routine.
+ *
+ * @par Description:
+ * This API is used to write the address of data specified by bufferAddr into a queue.
+ * It is safe to use this API from within an interrupt service routine.
+ * @attention
+ * <ul>
+ * <li>The specific queue should be created firstly.</li>
+ * <li>This API write data into a queue in unblocking modes.</li>
+ * <li>This API cannot be called before the kernel is initialized.</li>
+ * <li>The address of the data of the size specified by bufferSize and stored at the address specified by
+ * BufferAddr is to be written.</li>
+ * <li>The bufferSize is not really used in LOS_QueueWriteIsr, because the interface is only used to write the address
+ * of data specified by bufferAddr into a queue.</li>
+ * </ul>
+ *
+ * @param queueID        [IN]        Queue ID created by LOS_QueueCreate. The value range is
+ * [1,LOSCFG_BASE_IPC_QUEUE_LIMIT].
+ * @param bufferAddr     [IN]        Starting address that stores the data to be written. The starting address
+ * must not be null.
+ * @param bufferSize     [IN]        Passed-in buffer size, which must not be 0. The value range is [1,0xffffffff].
+ *
+ * @retval   #LOS_OK                                The data is successfully written into the queue.
+ * @retval   #LOS_ERRNO_QUEUE_INVALID               The queue handle passed in during queue writing is invalid.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_PTR_NULL        The pointer passed in during queue writing is null.
+ * @retval   #LOS_ERRNO_QUEUE_WRITESIZE_ISZERO      The buffer size passed in during queue writing is 0.
+ * @retval   #LOS_ERRNO_QUEUE_NOT_CREATE            The queue into which the data is written is not created.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_SIZE_TOO_BIG    The buffer size passed in during queue writing is bigger than
+ * the queue size.
+ * @retval   #LOS_ERRNO_QUEUE_ISFULL                No free node is available during queue writing.
+ * @par Dependency:
+ * <ul><li>los_queue.h: The header file that contains the API declaration.</li></ul>
+ * @see LOS_QueueRead | LOS_QueueCreate
+ */
+STATIC INLINE UINT32 LOS_QueueWriteIsr(UINT32 queueID,
+                                       VOID *bufferAddr,
+                                       UINT32 bufferSize)
+{
+    return LOS_QueueWrite(queueID, bufferAddr, bufferSize, LOS_NO_WAIT);
+}
+
 /**
  * @ingroup los_queue
  * @brief Write data into a queue header.
@@ -676,6 +849,48 @@ extern UINT32 LOS_QueueWriteHead(UINT32 queueID,
                                  UINT32 bufferSize,
                                  UINT32 timeOut);
 
+/**
+ * @ingroup los_queue
+ * @brief Write data into a queue header in interrupt service routine.
+ *
+ * @par Description:
+ * This API is used to write the data of the size specified by bufferSize and stored at the address specified by
+ * bufferAddr into a queue header.It is safe to use this API from within an interrupt service routine.
+ * @attention
+ * <ul>
+ * <li>This API cannot be called before the kernel is initialized.</li>
+ * <li>This API write data into a queue header in unblocking modes.</li>
+ * <li>The address of the data of the size specified by bufferSize and stored at the address specified by
+ * BufferAddr is to be written.</li>
+ * <li>LOS_QueueRead and LOS_QueueWriteHeadIsr are a set of interfaces, and the two groups of interfaces need to be used.
+ * <li>
+ * </ul>
+ *
+ * @param queueID        [IN]        Queue ID created by LOS_QueueCreate. The value range is
+ * [1,LOSCFG_BASE_IPC_QUEUE_LIMIT].
+ * @param bufferAddr     [OUT]       Starting address that stores the data to be written. The starting address
+ * must not be null.
+ * @param bufferSize     [IN]        Passed-in buffer size, which must not be 0. The value range is [1,0xffffffff].
+ *
+ * @retval   #LOS_OK                                 The data is successfully written into the queue.
+ * @retval   #LOS_ERRNO_QUEUE_INVALID                The queue handle passed in during queue writing is invalid.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_PTR_NULL         The pointer passed in during queue writing is null.
+ * @retval   #LOS_ERRNO_QUEUE_WRITESIZE_ISZERO       The buffer size passed in during queue writing is 0.
+ * @retval   #LOS_ERRNO_QUEUE_NOT_CREATE             The queue into which the data is written is not created.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_SIZE_TOO_BIG     The buffer size passed in during queue writing is bigger than
+ * the queue size.
+ * @retval   #LOS_ERRNO_QUEUE_ISFULL                 No free node is available during queue writing.
+ * @par Dependency:
+ * <ul><li>los_queue.h: The header file that contains the API declaration.</li></ul>
+ * @see LOS_QueueRead | LOS_QueueCreate
+ */
+STATIC INLINE UINT32 LOS_QueueWriteHeadIsr(UINT32 queueID,
+                                           VOID *bufferAddr,
+                                           UINT32 bufferSize)
+{
+    return LOS_QueueWriteHead(queueID, bufferAddr, bufferSize, LOS_NO_WAIT);
+}
+
 /**
  * @ingroup los_queue
  * @brief Write data into a queue header.
@@ -723,6 +938,48 @@ extern UINT32 LOS_QueueWriteHeadCopy(UINT32 queueID,
                                      UINT32 bufferSize,
                                      UINT32 timeOut);
 
+/**
+ * @ingroup los_queue
+ * @brief Write data into a queue header in interrupt service routine.
+ *
+ * @par Description:
+ * This API is used to write the data of the size specified by bufferSize and stored at the address specified by
+ * bufferAddr into a queue header.It is safe to use this API from within an interrupt service routine.
+ * @attention
+ * <ul>
+ * <li>This API cannot be called before the kernel is initialized.</li>
+ * <li>This API write data into a queue header in unblocking modes.</li>
+ * <li>The address of the data of the size specified by bufferSize and stored at the address specified by
+ * BufferAddr is to be written.</li>
+ * <li>LOS_QueueReadCopy and LOS_QueueWriteHeadCopyIsr are a set of interfaces, and the two groups of interfaces need to be
+ * used.<li>
+ * </ul>
+ *
+ * @param queueID        [IN]        Queue ID created by LOS_QueueCreate. The value range is
+ * [1,LOSCFG_BASE_IPC_QUEUE_LIMIT].
+ * @param bufferAddr     [OUT]       Starting address that stores the data to be written.
+ * The starting address must not be null.
+ * @param bufferSize     [IN]        Passed-in buffer size, which must not be 0. The value range is [1,0xffffffff].
+ *
+ * @retval   #LOS_OK                                 The data is successfully written into the queue.
+ * @retval   #LOS_ERRNO_QUEUE_INVALID                The queue handle passed in during queue writing is invalid.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_PTR_NULL         The pointer passed in during queue writing is null.
+ * @retval   #LOS_ERRNO_QUEUE_WRITESIZE_ISZERO       The buffer size passed in during queue writing is 0.
+ * @retval   #LOS_ERRNO_QUEUE_NOT_CREATE             The queue into which the data is written is not created.
+ * @retval   #LOS_ERRNO_QUEUE_WRITE_SIZE_TOO_BIG     The buffer size passed in during queue writing is bigger than
+ * the queue size.
+ * @retval   #LOS_ERRNO_QUEUE_ISFULL                 No free node is available during queue writing.
+ * @par Dependency:
+ * <ul><li>los_queue.h: The header file that contains the API declaration.</li></ul>
+ * @see LOS_QueueWrite | LOS_QueueWriteHeadIsr
+ */
+STATIC INLINE UINT32 LOS_QueueWriteHeadCopyIsr(UINT32 queueID,
+                                               VOID *bufferAddr,
+                                               UINT32 bufferSize)
+{
+    return LOS_QueueWriteHeadCopy(queueID, bufferAddr, bufferSize, LOS_NO_WAIT);
+}
+
 /**
  * @ingroup los_queue
  * @brief Delete a queue.

kernel/src/los_queue.c

@@ -37,7 +37,6 @@
 #include "los_interrupt.h"
 #include "los_membox.h"
 #include "los_memory.h"
-#include "los_task.h"
 #include "los_sched.h"
 #include <stdint.h>
 

testsuites/sample/kernel/queue/BUILD.gn

@@ -164,6 +164,22 @@ static_library("test_queue") {
     "It_los_queue_head_040.c",
     "It_los_queue_head_041.c",
     "It_los_queue_head_042.c",
+    "It_los_queue_isr_001.c",
+    "It_los_queue_isr_002.c",
+    "It_los_queue_isr_003.c",
+    "It_los_queue_isr_004.c",
+    "It_los_queue_isr_005.c",
+    "It_los_queue_isr_006.c",
+    "It_los_queue_isr_007.c",
+    "It_los_queue_isr_008.c",
+    "It_los_queue_isr_009.c",
+    "It_los_queue_isr_010.c",
+    "It_los_queue_isr_011.c",
+    "It_los_queue_isr_012.c",
+    "It_los_queue_isr_013.c",
+    "It_los_queue_isr_014.c",
+    "It_los_queue_isr_015.c",
+    "It_los_queue_isr_016.c",
     "It_los_queue_static_001.c",
     "It_los_queue_static_002.c",
     "It_los_queue_static_003.c",

testsuites/sample/kernel/queue/It_los_queue.c

@@ -151,7 +151,22 @@ VOID ItSuiteLosQueue(VOID)
     ItLosQueueHead040();
     ItLosQueueHead041();
     ItLosQueueHead042();
-
+    ItLosQueueIsr001();
+    ItLosQueueIsr002();
+    ItLosQueueIsr003();
+    ItLosQueueIsr004();
+    ItLosQueueIsr005();
+    ItLosQueueIsr006();
+    ItLosQueueIsr007();
+    ItLosQueueIsr008();
+    ItLosQueueIsr009();
+    ItLosQueueIsr010();
+    ItLosQueueIsr011();
+    ItLosQueueIsr012();
+    ItLosQueueIsr013();
+    ItLosQueueIsr014();
+    ItLosQueueIsr015();
+    ItLosQueueIsr016();
 #if (LOS_KERNEL_TEST_FULL == 1)
 #if (LOS_KERNEL_HWI_TEST == 1)
     ItLosQueue044();

testsuites/sample/kernel/queue/It_los_queue.h

@@ -183,7 +183,22 @@ extern VOID ItLosQueueHead039(VOID);
 extern VOID ItLosQueueHead040(VOID);
 extern VOID ItLosQueueHead041(VOID);
 extern VOID ItLosQueueHead042(VOID);
-
+extern VOID ItLosQueueIsr001(VOID);
+extern VOID ItLosQueueIsr002(VOID);
+extern VOID ItLosQueueIsr003(VOID);
+extern VOID ItLosQueueIsr004(VOID);
+extern VOID ItLosQueueIsr005(VOID);
+extern VOID ItLosQueueIsr006(VOID);
+extern VOID ItLosQueueIsr007(VOID);
+extern VOID ItLosQueueIsr008(VOID);
+extern VOID ItLosQueueIsr009(VOID);
+extern VOID ItLosQueueIsr010(VOID);
+extern VOID ItLosQueueIsr011(VOID);
+extern VOID ItLosQueueIsr012(VOID);
+extern VOID ItLosQueueIsr013(VOID);
+extern VOID ItLosQueueIsr014(VOID);
+extern VOID ItLosQueueIsr015(VOID);
+extern VOID ItLosQueueIsr016(VOID);
 #if (LOSCFG_BASE_IPC_QUEUE_STATIC == 1)
 extern VOID ItLosQueueStatic001(VOID);
 extern VOID ItLosQueueStatic002(VOID);

testsuites/sample/kernel/queue/It_los_queue_isr_001.c

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+    
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr001(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr001", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_002.c

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_QUEUE_NOT_CREATE, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_PARA_ISZERO, ret, EXIT);
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_NOT_CREATE, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_QUEUE_NOT_CREATE, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr002(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr002", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_003.c

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, 0);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_QUEUE_WRITE_SIZE_TOO_BIG, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, 1);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+    
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, 1, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr003(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr003", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_004.c

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, 0);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, 4);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+    
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, 1, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr004(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr004", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_005.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr005(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr005", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_006.c

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+CHAR buff1[QUEUE_BASE_MSGSIZE] = "UniDSP";
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff2 + index), buff1[index],
+            *((CHAR *)(intptr_t)buff2 + index), EXIT);
+    }
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+
+VOID ItLosQueueIsr006(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr006", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_007.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr((UINT32)-1, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_QUEUE_INVALID, ret);
+
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr007(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr007", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+
+

testsuites/sample/kernel/queue/It_los_queue_isr_008.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr(OS_ALL_IPC_QUEUE_LIMIT + 1, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_QUEUE_INVALID, ret);
+
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR *buff2 = NULL;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret, EXIT);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr008(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr008", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+
+

testsuites/sample/kernel/queue/It_los_queue_isr_009.c

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR *buff2 = NULL;
+
+    ret = LOS_QueueReadIsr(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    ret = LOS_QueueWrite(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr009(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr009", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_010.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR *buff2 = NULL;
+    
+    ret = LOS_QueueReadIsr(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_QUEUE_ISEMPTY, ret);
+}
+
+static VOID HwiF02(VOID)
+{
+    UINT32 ret;
+    CHAR *buff2 = NULL;
+
+    ret = LOS_QueueReadIsr(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST0, hwiPrio, mode, (HWI_PROC_FUNC)HwiF02, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ret = LOS_QueueWrite(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    TestHwiTrigger(HWI_NUM_TEST0);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    TestHwiDelete(HWI_NUM_TEST0);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr010(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr010", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_011.c

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static CHAR g_buff[QUEUE_BASE_MSGSIZE] = "UniDSP";
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR *buff2 = NULL;
+
+    ret = LOS_QueueReadIsr(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_ASSERT_EQUAL_VOID(*((CHAR *)(intptr_t)buff2 + index), g_buff[index],
+            *((CHAR *)(intptr_t)buff2 + index));
+    }
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    ret = LOS_QueueWrite(g_testQueueID01, &g_buff, QUEUE_BASE_MSGSIZE, 0);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr011(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr011", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_012.c

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static VOID TaskF01(VOID)
+{
+    UINT32 ret;
+    CHAR *buff2 = NULL;
+
+    g_testCount++;
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE,LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    g_testCount++;
+    return;
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TSK_INIT_PARAM_S task1 = { 0 };
+    task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
+    task1.uwStackSize = TASK_STACK_SIZE_TEST;
+    task1.pcName = "Tsk001A";
+    task1.usTaskPrio = TASK_PRIO_TEST - 1;
+    task1.uwResved = LOS_TASK_STATUS_DETACHED;
+    g_testCount = 0;
+    ret = LOS_TaskCreate(&g_testTaskID01, &task1);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+    
+    ICUNIT_ASSERT_EQUAL(g_testCount, 2, g_testCount);
+
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr012(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr012", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_013.c

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteIsr(g_testQueueID01, &buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static VOID TaskF01(VOID)
+{
+    UINT32 ret;
+    CHAR *buff2 = NULL;
+
+    g_testCount++;
+    ret = LOS_QueueRead(g_testQueueID01, &buff2, QUEUE_BASE_MSGSIZE,LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    g_testCount++;
+    return;
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TSK_INIT_PARAM_S task1 = { 0 };
+    task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
+    task1.uwStackSize = TASK_STACK_SIZE_TEST;
+    task1.pcName = "Tsk001A";
+    task1.usTaskPrio = TASK_PRIO_TEST + 1;
+    task1.uwResved = LOS_TASK_STATUS_DETACHED;
+    g_testCount = 0;
+    ret = LOS_TaskCreate(&g_testTaskID01, &task1);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    LOS_TaskDelay(1);
+
+    ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+    ICUNIT_ASSERT_EQUAL(g_testCount, 1, g_testCount);
+
+    LOS_TaskDelay(1);
+
+    ICUNIT_ASSERT_EQUAL(g_testCount, 2, g_testCount);
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr013(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr013", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_014.c

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+
+    ret = LOS_QueueWriteCopyIsr(g_testQueueID01, buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static VOID TaskF01(VOID)
+{
+    UINT32 ret;
+    UINT32 msgSize = (UINT32)QUEUE_BASE_MSGSIZE;
+    CHAR buff[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    CHAR buff2[QUEUE_SHORT_BUFFER_LENGTH] = " ";
+
+    ret = LOS_QueueReadCopy(g_testQueueID01, buff2, &msgSize, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff2 + index), buff[index],
+            *((CHAR *)(intptr_t)buff2 + index), EXIT);
+    }
+
+EXIT:
+    return;
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TSK_INIT_PARAM_S task1 = { 0 };
+    task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
+    task1.uwStackSize = TASK_STACK_SIZE_TEST;
+    task1.pcName = "Tsk001A";
+    task1.usTaskPrio = TASK_PRIO_TEST - 1;
+    task1.uwResved = LOS_TASK_STATUS_DETACHED;
+    g_testCount = 0;
+    ret = LOS_TaskCreate(&g_testTaskID01, &task1);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr014(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr014", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_015.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static CHAR g_buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+static CHAR g_buff2[QUEUE_SHORT_BUFFER_LENGTH] = "DOPRA";
+static CHAR g_buff3[QUEUE_SHORT_BUFFER_LENGTH] = "TEST";
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+
+    ret = LOS_QueueWriteHeadIsr(g_testQueueID01, &g_buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+
+    ret = LOS_QueueWriteHeadIsr(g_testQueueID01, &g_buff2, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+
+    ret = LOS_QueueWriteHeadIsr(g_testQueueID01, &g_buff3, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static VOID TaskF01(VOID)
+{
+    UINT32 ret;
+    CHAR buffA[QUEUE_SHORT_BUFFER_LENGTH] = "TEST";
+    CHAR buffB[QUEUE_SHORT_BUFFER_LENGTH] = "DOPRA";
+    CHAR buffC[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    CHAR *buff = NULL;
+    
+    ret = LOS_QueueRead(g_testQueueID01, &buff, QUEUE_BASE_MSGSIZE, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff + index), buffA[index],
+            *((CHAR *)(intptr_t)buff + index), EXIT);
+    }
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff, QUEUE_BASE_MSGSIZE, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff + index), buffB[index],
+            *((CHAR *)(intptr_t)buff + index), EXIT);
+    }
+
+    ret = LOS_QueueRead(g_testQueueID01, &buff, QUEUE_BASE_MSGSIZE, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff + index), buffC[index],
+            *((CHAR *)(intptr_t)buff + index), EXIT);
+    }
+
+EXIT:
+    return;
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TSK_INIT_PARAM_S task1 = { 0 };
+    task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
+    task1.uwStackSize = TASK_STACK_SIZE_TEST;
+    task1.pcName = "Tsk001A";
+    task1.usTaskPrio = TASK_PRIO_TEST - 1;
+    task1.uwResved = LOS_TASK_STATUS_DETACHED;
+    g_testCount = 0;
+    ret = LOS_TaskCreate(&g_testTaskID01, &task1);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr015(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr015", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+

testsuites/sample/kernel/queue/It_los_queue_isr_016.c

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2023 Hunan OpenValley Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "It_los_queue.h"
+
+
+static VOID HwiF01(VOID)
+{
+    UINT32 ret;
+    CHAR buff1[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    CHAR buff2[QUEUE_SHORT_BUFFER_LENGTH] = "DOPRA";
+    CHAR buff3[QUEUE_SHORT_BUFFER_LENGTH] = "TEST";
+
+    ret = LOS_QueueWriteHeadCopyIsr(g_testQueueID01, buff1, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+
+    ret = LOS_QueueWriteHeadCopyIsr(g_testQueueID01, buff2, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+
+    ret = LOS_QueueWriteHeadCopyIsr(g_testQueueID01, buff3, QUEUE_BASE_MSGSIZE);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+}
+
+static VOID TaskF01(VOID)
+{
+    UINT32 ret;
+    UINT32 msgSize = (UINT32)QUEUE_BASE_MSGSIZE;
+    CHAR buffA[QUEUE_SHORT_BUFFER_LENGTH] = "TEST";
+    CHAR buffB[QUEUE_SHORT_BUFFER_LENGTH] = "DOPRA";
+    CHAR buffC[QUEUE_SHORT_BUFFER_LENGTH] = "UniDSP";
+    CHAR buff[QUEUE_SHORT_BUFFER_LENGTH] = " ";
+
+    ret = LOS_QueueReadCopy(g_testQueueID01, buff, &msgSize, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff + index), buffA[index],
+            *((CHAR *)(intptr_t)buff + index), EXIT);
+    }
+
+    ret = LOS_QueueReadCopy(g_testQueueID01, buff, &msgSize, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff + index), buffB[index],
+            *((CHAR *)(intptr_t)buff + index), EXIT);
+    }
+
+    ret = LOS_QueueReadCopy(g_testQueueID01, buff, &msgSize, LOS_WAIT_FOREVER);
+    ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
+    for (UINT8 index = 0; index < QUEUE_BASE_MSGSIZE - 1; index++) { // 7, QUEUE_BASE_MSGSIZE - 1
+        ICUNIT_GOTO_EQUAL(*((CHAR *)(intptr_t)buff + index), buffC[index],
+            *((CHAR *)(intptr_t)buff + index), EXIT);
+    }
+
+EXIT:
+    return;
+}
+
+static UINT32 Testcase(VOID)
+{
+    UINT32 ret;
+    HWI_PRIOR_T hwiPrio = 3;
+    HWI_MODE_T mode = 0;
+    HwiIrqParam irqParam;
+
+    ret = LOS_QueueCreate("Q1", QUEUE_BASE_NUM, &g_testQueueID01, 0, QUEUE_BASE_MSGSIZE);
+    ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
+
+    (VOID)memset_s(&irqParam, sizeof(HwiIrqParam), 0, sizeof(HwiIrqParam));
+    irqParam.pDevId = 0;
+    ret = LOS_HwiCreate(HWI_NUM_TEST, hwiPrio, mode, (HWI_PROC_FUNC)HwiF01, &irqParam);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+     
+    TSK_INIT_PARAM_S task1 = { 0 };
+    task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskF01;
+    task1.uwStackSize = TASK_STACK_SIZE_TEST;
+    task1.pcName = "Tsk001A";
+    task1.usTaskPrio = TASK_PRIO_TEST - 1;
+    task1.uwResved = LOS_TASK_STATUS_DETACHED;
+    g_testCount = 0;
+    ret = LOS_TaskCreate(&g_testTaskID01, &task1);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+
+    TestHwiTrigger(HWI_NUM_TEST);
+
+EXIT:
+    TestHwiDelete(HWI_NUM_TEST);
+    ret = LOS_QueueDelete(g_testQueueID01);
+    ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
+    return LOS_OK;
+}
+
+VOID ItLosQueueIsr016(VOID)
+{
+    TEST_ADD_CASE("ItLosQueueIsr016", Testcase, TEST_LOS, TEST_QUE, TEST_LEVEL1, TEST_FUNCTION);
+}
+