text: /*
   * Copyright (c) 2016 Intel Corporation
   *
   * SPDX-License-Identifier: Apache-2.0
   */
  
  #include <ztest.h>
  
  #define STACK_SIZE	(1024 + CONFIG_TEST_EXTRA_STACKSIZE)
  #define PIPE_LEN	(4 * 16)
  #define BYTES_TO_WRITE	16
  #define BYTES_TO_READ BYTES_TO_WRITE
  
  K_HEAP_DEFINE(mpool, PIPE_LEN * 1);
  
  static ZTEST_DMEM unsigned char __aligned(4) data[] =
  "abcd1234$%^&PIPEefgh5678!/?*EPIPijkl9012[]<>PEPImnop3456{}()IPEP";
  BUILD_ASSERT(sizeof(data) >= PIPE_LEN);
  
  /**TESTPOINT: init via K_PIPE_DEFINE*/
  K_PIPE_DEFINE(kpipe, PIPE_LEN, 4);
  K_PIPE_DEFINE(khalfpipe, (PIPE_LEN / 2), 4);
  K_PIPE_DEFINE(kpipe1, PIPE_LEN, 4);
  K_PIPE_DEFINE(pipe_test_alloc, PIPE_LEN, 4);
  struct k_pipe pipe, pipe1;
  
  K_THREAD_STACK_DEFINE(tstack, STACK_SIZE);
  K_THREAD_STACK_DEFINE(tstack1, STACK_SIZE);
  K_THREAD_STACK_DEFINE(tstack2, STACK_SIZE);
  struct k_thread tdata;
  struct k_thread tdata1;
  struct k_thread tdata2;
  K_SEM_DEFINE(end_sema, 0, 1);
  
  #ifdef CONFIG_64BIT
  #define SZ 256
  #else
  #define SZ 128
  #endif
  K_HEAP_DEFINE(test_pool, SZ * 4);
  
  struct mem_block {
  	void *data;
  };
  
  static void tpipe_put(struct k_pipe *ppipe, k_timeout_t timeout)
  {
  	size_t to_wt, wt_byte = 0;
  
  	for (int i = 0; i < PIPE_LEN; i += wt_byte) {
  		/**TESTPOINT: pipe put*/
  		to_wt = (PIPE_LEN - i) >= BYTES_TO_WRITE ?
  			BYTES_TO_WRITE : (PIPE_LEN - i);
  		zassert_false(k_pipe_put(ppipe, &data[i], to_wt,
  					 &wt_byte, 1, timeout), NULL);
  		zassert_true(wt_byte == to_wt || wt_byte == 1, NULL);
  	}
  }
  
  static void tpipe_get(struct k_pipe *ppipe, k_timeout_t timeout)
  {
  	unsigned char rx_data[PIPE_LEN];
  	size_t to_rd, rd_byte = 0;
  
  	/*get pipe data from "pipe_put"*/
  	for (int i = 0; i < PIPE_LEN; i += rd_byte) {
  		/**TESTPOINT: pipe get*/
  		to_rd = (PIPE_LEN - i) >= BYTES_TO_READ ?
  			BYTES_TO_READ : (PIPE_LEN - i);
  		zassert_false(k_pipe_get(ppipe, &rx_data[i], to_rd,
  					 &rd_byte, 1, timeout), NULL);
  		zassert_true(rd_byte == to_rd || rd_byte == 1, NULL);
  	}
  	for (int i = 0; i < PIPE_LEN; i++) {
  		zassert_equal(rx_data[i], data[i], NULL);
  	}
  }
  
  static void tThread_entry(void *p1, void *p2, void *p3)
  {
  	tpipe_get((struct k_pipe *)p1, K_FOREVER);
  	k_sem_give(&end_sema);
  
  	tpipe_put((struct k_pipe *)p1, K_NO_WAIT);
  	k_sem_give(&end_sema);
  }
  
  static void tpipe_thread_thread(struct k_pipe *ppipe)
  {
  	/**TESTPOINT: thread-thread data passing via pipe*/
  	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
  				      tThread_entry, ppipe, NULL, NULL,
  				      K_PRIO_PREEMPT(0),
  				      K_INHERIT_PERMS | K_USER, K_NO_WAIT);
  
  	tpipe_put(ppipe, K_NO_WAIT);
  	k_sem_take(&end_sema, K_FOREVER);
  
  	k_sem_take(&end_sema, K_FOREVER);
  	tpipe_get(ppipe, K_FOREVER);
  
  	/* clear the spawned thread avoid side effect */
  	k_thread_abort(tid);
  }
  
  static void tpipe_kthread_to_kthread(struct k_pipe *ppipe)
  {
  	/**TESTPOINT: thread-thread data passing via pipe*/
  	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
  				      tThread_entry, ppipe, NULL, NULL,
  				      K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
  
  	tpipe_put(ppipe, K_NO_WAIT);
  	k_sem_take(&end_sema, K_FOREVER);
  
  	k_sem_take(&end_sema, K_FOREVER);
  	tpipe_get(ppipe, K_FOREVER);
  
  	/* clear the spawned thread avoid side effect */
  	k_thread_abort(tid);
  }
  
  static void tpipe_put_no_wait(struct k_pipe *ppipe)
  {
  	size_t to_wt, wt_byte = 0;
  
  	for (int i = 0; i < PIPE_LEN; i += wt_byte) {
  	/**TESTPOINT: pipe put*/
  		to_wt = (PIPE_LEN - i) >= BYTES_TO_WRITE ?
  			BYTES_TO_WRITE : (PIPE_LEN - i);
  		zassert_false(k_pipe_put(ppipe, &data[i], to_wt,
  					&wt_byte, 1, K_NO_WAIT), NULL);
  		zassert_true(wt_byte == to_wt || wt_byte == 1, NULL);
  	}
  }
  
  static void tpipe_put_small_size(struct k_pipe *ppipe, k_timeout_t timeout)
  {
  	size_t to_wt, wt_byte = 0;
  
  	for (int i = 0; i < PIPE_LEN; i += wt_byte) {
  		/**TESTPOINT: pipe put*/
  		to_wt = (PIPE_LEN - i) >= 24 ?
  			24 : (PIPE_LEN - i);
  		k_pipe_put(ppipe, &data[i], to_wt, &wt_byte, 1, timeout);
  	}
  }
  
  static void tpipe_get_small_size(struct k_pipe *ppipe, k_timeout_t timeout)
  {
  	unsigned char rx_data[PIPE_LEN];
  	size_t to_rd, rd_byte = 0;
  
  	/*get pipe data from "pipe_put"*/
  	for (int i = 0; i < PIPE_LEN; i += rd_byte) {
  		/**TESTPOINT: pipe get*/
  		to_rd = (PIPE_LEN - i) >= 24 ?
  			24 : (PIPE_LEN - i);
  		zassert_false(k_pipe_get(ppipe, &rx_data[i], to_rd,
  					 &rd_byte, 1, timeout), NULL);
  	}
  }
  
  
  /**
   * @brief Test Initialization and buffer allocation of pipe,
   * with various parameters
   * @see k_pipe_alloc_init(), k_pipe_cleanup()
   */
  void test_pipe_alloc(void)
  {
  	int ret;
  
  	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN), NULL);
  
  	tpipe_kthread_to_kthread(&pipe_test_alloc);
  	k_pipe_cleanup(&pipe_test_alloc);
  
  	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, 0), NULL);
  	k_pipe_cleanup(&pipe_test_alloc);
  
  	ret = k_pipe_alloc_init(&pipe_test_alloc, 2048);
  	zassert_true(ret == -ENOMEM,
  		"resource pool max block size is not smaller then requested buffer");
  }
  
  static void thread_for_get_forever(void *p1, void *p2, void *p3)
  {
  	tpipe_get((struct k_pipe *)p1, K_FOREVER);
  }
  
  void test_pipe_cleanup(void)
  {
  	int ret;
  
  	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN), NULL);
  
  	/**TESTPOINT: test if a dynamically allocated buffer can be freed*/
  	ret = k_pipe_cleanup(&pipe_test_alloc);
  	zassert_true((ret == 0) && (pipe_test_alloc.buffer == NULL),
  			"Failed to free buffer with k_pipe_cleanup().");
  
  	/**TESTPOINT: nothing to do with k_pipe_cleanup() for static buffer in pipe*/
  	ret = k_pipe_cleanup(&kpipe);
  	zassert_true((ret == 0) && (kpipe.buffer != NULL),
  			"Static buffer should not be freed.");
  
  	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN), NULL);
  
  	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
  			thread_for_get_forever, &pipe_test_alloc, NULL,
  			NULL, K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
  	k_sleep(K_MSEC(100));
  
  	ret = k_pipe_cleanup(&pipe_test_alloc);
  	zassert_true(ret == -EAGAIN, "k_pipe_cleanup() should not return with 0.");
  	k_thread_abort(tid);
  }
  
  static void thread_handler(void *p1, void *p2, void *p3)
  {
  	tpipe_put_no_wait((struct k_pipe *)p1);
  	k_sem_give(&end_sema);
  }
  
  /**
   * @addtogroup kernel_pipe_tests
   * @{
   */
  
  /**
   * @brief Test pipe data passing between threads
   *
   * @ingroup kernel_pipe_tests
   *
   * @details
   * Test Objective:
   * - Verify data passing with "pipe put/get" APIs between
   * threads
   *
   * Testing techniques:
   * - function and block box testing,Interface testing,
   * Dynamic analysis and testing.
   *
   * Prerequisite Conditions:
   * - CONFIG_TEST_USERSPACE.
   *
   * Input Specifications:
   * - N/A
   *
   * Test Procedure:
   * -# Initialize a pipe, which is defined at run time.
   * -# Create a thread (A).
   * -# In A thread, check if it can get data, which is sent
   * by main thread via the pipe.
   * -# In A thread, send data to main thread via the pipe.
   * -# In main thread, send data to A thread  via the pipe.
   * -# In main thread, check if it can get data, which is sent
   * by A thread.
   * -# Do the same testing with a pipe, which is defined at compile
   * time
   *
   * Expected Test Result:
   * - Data can be sent/received between threads.
   *
   * Pass/Fail Criteria:
   * - Successful if check points in test procedure are all passed, otherwise failure.
   *
   * Assumptions and Constraints:
   * - N/A
   *
   * @see k_pipe_init(), k_pipe_put(), #K_PIPE_DEFINE(x)
   */
  
  void test_pipe_thread2thread(void)
  {
  	/**TESTPOINT: test k_pipe_init pipe*/
  	k_pipe_init(&pipe, data, PIPE_LEN);
  	tpipe_thread_thread(&pipe);
  
  	/**TESTPOINT: test K_PIPE_DEFINE pipe*/
  	tpipe_thread_thread(&kpipe);
  }
  
  #ifdef CONFIG_USERSPACE
  /**
   * @brief Test data passing using pipes between user threads
   * @see k_pipe_init(), k_pipe_put(), #K_PIPE_DEFINE(x)
   */
  void test_pipe_user_thread2thread(void)
  {
  	/**TESTPOINT: test k_object_alloc pipe*/
  	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
  
  	zassert_true(p != NULL, NULL);
  
  	/**TESTPOINT: test k_pipe_alloc_init*/
  	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
  	tpipe_thread_thread(p);
  
  }
  #endif
  
  /**
   * @brief Test resource pool free
   * @see k_heap_alloc()
   */
  #ifdef CONFIG_USERSPACE
  void test_resource_pool_auto_free(void)
  {
  	/* Pool has 2 blocks, both should succeed if kernel object and pipe
  	 * buffer are auto-freed when the allocating threads exit
  	 */
  	zassert_true(k_heap_alloc(&test_pool, 64, K_NO_WAIT) != NULL, NULL);
  	zassert_true(k_heap_alloc(&test_pool, 64, K_NO_WAIT) != NULL, NULL);
  }
  #endif
  
  static void tThread_half_pipe_put(void *p1, void *p2, void *p3)
  {
  	tpipe_put((struct k_pipe *)p1, K_FOREVER);
  }
  
  static void tThread_half_pipe_get(void *p1, void *p2, void *p3)
  {
  	tpipe_get((struct k_pipe *)p1, K_FOREVER);
  }
  
  /**
   * @brief Test put/get with smaller pipe buffer
   * @see k_pipe_put(), k_pipe_get()
   */
  void test_half_pipe_put_get(void)
  {
  	/**TESTPOINT: thread-thread data passing via pipe*/
  	k_tid_t tid1 = k_thread_create(&tdata1, tstack1, STACK_SIZE,
  				      tThread_half_pipe_get, &khalfpipe,
  				      NULL, NULL, K_PRIO_PREEMPT(0),
  				      K_INHERIT_PERMS | K_USER, K_NO_WAIT);
  
  	k_tid_t tid2 = k_thread_create(&tdata2, tstack2, STACK_SIZE,
  				      tThread_half_pipe_get, &khalfpipe,
  				      NULL, NULL, K_PRIO_PREEMPT(0),
  				      K_INHERIT_PERMS | K_USER, K_NO_WAIT);
  
  	k_sleep(K_MSEC(100));
  	tpipe_put_small_size(&khalfpipe, K_NO_WAIT);
  
  	/* clear the spawned thread avoid side effect */
  	k_thread_abort(tid1);
  	k_thread_abort(tid2);
  }
  
  void test_pipe_get_put(void)
  {
  	unsigned char rx_data[PIPE_LEN];
  	size_t rd_byte = 0;
  	int ret;
  
  	/* TESTPOINT: min_xfer > bytes_to_read */
  	ret = k_pipe_get(&kpipe, &rx_data[0], 1, &rd_byte, 24, K_NO_WAIT);
  	zassert_true(ret == -EINVAL, NULL);
  	ret = k_pipe_get(&kpipe, &rx_data[0], 24, NULL, 1, K_NO_WAIT);
  	zassert_true(ret == -EINVAL, NULL);
  
  	/**TESTPOINT: thread-thread data passing via pipe*/
  	k_tid_t tid1 = k_thread_create(&tdata1, tstack1, STACK_SIZE,
  				      tThread_half_pipe_put, &khalfpipe,
  				      NULL, NULL, K_PRIO_PREEMPT(0),
  				      K_INHERIT_PERMS | K_USER, K_NO_WAIT);
  
  	k_tid_t tid2 = k_thread_create(&tdata2, tstack2, STACK_SIZE,
  				      tThread_half_pipe_put, &khalfpipe,
  				      NULL, NULL, K_PRIO_PREEMPT(0),
  				      K_INHERIT_PERMS | K_USER, K_NO_WAIT);
  
  	k_sleep(K_MSEC(100));
  	tpipe_get_small_size(&khalfpipe, K_NO_WAIT);
  
  	/* clear the spawned thread avoid side effect */
  	k_thread_abort(tid1);
  	k_thread_abort(tid2);
  }
  
  /**
   * @brief Test pending reader in pipe
   * @see k_pipe_put(), k_pipe_get()
   */
  void test_pipe_reader_wait(void)
  {
  	/**TESTPOINT: test k_pipe_block_put with semaphore*/
  	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
  					thread_handler, &kpipe1, NULL, NULL,
  					K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
  
  	tpipe_get(&kpipe1, K_FOREVER);
  	k_sem_take(&end_sema, K_FOREVER);
  	k_thread_abort(tid);
  }
  
  /**
   * @}
   */
  