diff options
Diffstat (limited to 'test/smp/regression/threadx_byte_memory_basic_test.c')
| -rw-r--r-- | test/smp/regression/threadx_byte_memory_basic_test.c | 1064 |
1 files changed, 1064 insertions, 0 deletions
diff --git a/test/smp/regression/threadx_byte_memory_basic_test.c b/test/smp/regression/threadx_byte_memory_basic_test.c new file mode 100644 index 00000000..9fffc840 --- /dev/null +++ b/test/smp/regression/threadx_byte_memory_basic_test.c @@ -0,0 +1,1064 @@ +/* This test is designed to test simple memory byte pool creation, deletion, and + allocates and releases. */ + +#include <stdio.h> +#include "tx_api.h" + +typedef struct BYTE_MEMORY_TEST_STRUCT +{ + ULONG first; + ULONG second; + TX_BYTE_POOL pool; + ULONG first_middle; + ULONG second_middle; + ULONG pool_area[2048/sizeof(ULONG)]; + ULONG next_to_last; + ULONG last; + +} BYTE_MEMORY_TEST; + +static BYTE_MEMORY_TEST byte_memory; + + +/* Define external reference to byte pool creation status. */ + +extern UINT test_byte_pool_create_init; + + + +/* Define the ISR dispatch. */ + +extern VOID (*test_isr_dispatch)(void); + +UINT _txe_byte_pool_create(TX_BYTE_POOL *pool_ptr, CHAR *name_ptr, VOID *pool_start, + ULONG pool_size, UINT pool_control_block_size); + + +static unsigned long thread_0_counter = 0; +static TX_THREAD thread_0; + + +static TX_BYTE_POOL pool_0; +static TX_BYTE_POOL pool_1; +static TX_BYTE_POOL pool_2; +static TX_BYTE_POOL pool_3; + +static TX_BYTE_POOL pool_4; +static UCHAR *search_ptr_1; +static UCHAR *block_0; +static UCHAR *block_1; +static UCHAR *block_2; +static UCHAR *block_3; +static UCHAR *block_4; +static CHAR *pool_4_memory; +static TX_TIMER timer_0; + + +static unsigned long error = 0; +static unsigned long timer_executed = 0; +static unsigned long isr_executed = 0; + + +/* Define thread prototypes. */ + +static void thread_0_entry(ULONG thread_input); +UINT _tx_byte_release(VOID *memory_ptr); + + +/* Prototype for test control return. */ + +void test_control_return(UINT status); + + +/* Define the timer for this test. */ + +static void timer_entry(ULONG i) +{ + +#ifndef TX_DISABLE_ERROR_CHECKING + +UINT status; +CHAR *pointer; + + + /* Determine if calling byte pool create from initialization was successful. */ + if (test_byte_pool_create_init != TX_SUCCESS) + { + + /* Error! */ + error++; + } + + /* Attempt to create a byte pool from a timer. */ + pointer = (CHAR *) 0x30000; + status = tx_byte_pool_create(&pool_2, "pool 2", pointer, 108); + + /* Check status. */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + /* Attempt to create a byte pool with an invalid size. */ + status = _txe_byte_pool_create(&pool_3, "pool 3", pointer, + 108, (sizeof(TX_BYTE_POOL)+1)); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Error! */ + error++; + } + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + /* Try to delete a byte pool from a timer. */ + status = tx_byte_pool_delete(&pool_0); + + /* Check status. */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + /* Attempt to release byte memory from timer. */ + pointer = (CHAR *) 0x30000; + status = tx_byte_release(pointer); + + /* Check for error status! */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + timer_executed = 1; +#endif +} + +/* Define the ISR dispatch routine. */ + +static void test_isr(void) +{ + +#ifndef TX_DISABLE_ERROR_CHECKING + +CHAR *pointer; +UINT status; + + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer, 24, 100); + + /* Check status. */ + if (status != TX_WAIT_ERROR) + { + + /* Error! */ + error++; + } + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + + /* Attempt to create a byte pool from an ISR. */ + status = tx_byte_pool_create(&pool_2, "pool 0", (void *) 0x100000, 108); + + /* Check status. */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + /* Attempt to deleate a pool from an ISR. */ + status = tx_byte_pool_delete(&pool_0); + + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + /* Attempt to release byte memory from ISR. */ + pointer = (CHAR *) 0x30000; + status = tx_byte_release(pointer); + + /* Check for error status! */ + if (status != TX_CALLER_ERROR) + { + + /* Error! */ + error++; + } + + isr_executed = 1; +#endif +} + + +/* Define what the initial system looks like. */ + +#ifdef CTEST +void test_application_define(void *first_unused_memory) +#else +void threadx_byte_memory_basic_application_define(void *first_unused_memory) +#endif +{ + +UINT status; +CHAR *pointer; + + + /* Put first available memory address into a character pointer. */ + pointer = (CHAR *) first_unused_memory; + + /* Put system definition stuff in here, e.g. thread creates and other assorted + create information. */ + + status = tx_thread_create(&thread_0, "thread 0", thread_0_entry, 1, + pointer, TEST_STACK_SIZE_PRINTF, + 17, 17, 100, TX_AUTO_START); + pointer = pointer + TEST_STACK_SIZE_PRINTF; + + /* Check status. */ + if (status != TX_SUCCESS) + { + + printf("Running Byte Memory Basic Test...................................... ERROR #1\n"); + test_control_return(1); + } + + /* Create byte pools 0 and 1. */ + status = tx_byte_pool_create(&pool_0, "pool 0", pointer, 108); + pointer = pointer + 108; + + /* Check status. */ + if (status != TX_SUCCESS) + { + + printf("Running Byte Memory Basic Test...................................... ERROR #2\n"); + test_control_return(1); + } + + status = tx_byte_pool_create(&pool_1, "pool 1", pointer, 200); + pointer = pointer + 200; + + /* Check status. */ + if (status != TX_SUCCESS) + { + + printf("Running Byte Memory Basic Test...................................... ERROR #3\n"); + test_control_return(1); + } + + /* Test for search pointer issue on wrapped seach with prior block to search pointer merged. */ + status = tx_byte_pool_create(&pool_4, "pool 4", pointer, 300); + pool_4_memory = pointer; + pointer = pointer + 300; + + /* Check status. */ + if (status != TX_SUCCESS) + { + + printf("Running Byte Memory Basic Test...................................... ERROR #3a\n"); + test_control_return(1); + } + + /* Allocate first block. */ + status += tx_byte_allocate(&pool_4, (VOID **) &block_0, 80, TX_NO_WAIT); + + /* Save next search pointer. */ + search_ptr_1 = pool_4.tx_byte_pool_search; + + /* Clear the allocatged memory. */ + TX_MEMSET(block_0, 0, 80); + + /* Allocate another block. */ + status += tx_byte_allocate(&pool_4, (VOID **) &block_1, 80, TX_NO_WAIT); + + /* Clear the allocated block. */ + TX_MEMSET(block_1, 0, 80); + + /* Allocate the third and final block. */ + status += tx_byte_allocate(&pool_4, (VOID **) &block_2, 80, TX_NO_WAIT); + + /* Clear the allocated block. */ + TX_MEMSET(block_2, 0, 80); + + /* Release the first block. */ + status += tx_byte_release(block_0); + + /* Release the second block. */ + status += tx_byte_release(block_1); + + /* Manually move the search pointer to create the case where the search wraps and a merge happens on the search pointer + necessitating its update. */ + pool_4.tx_byte_pool_search = search_ptr_1; /* Point to the middle block. */ + + /* Allocate a larger block that will wrap the search and require moving as well as an update of the search pointer. */ + status += tx_byte_allocate(&pool_4, (VOID **) &block_3, 120, TX_NO_WAIT); + + /* Clear the newly allocated block. */ + TX_MEMSET(block_3, 0, 120); + + /* At this point, verify the search pointer was properly updated in the previous allocation. */ + status += tx_byte_allocate(&pool_4, (VOID **) &block_4, 40, TX_NO_WAIT); /* Should fail since search pointer is now invalid! */ + + /* Check status. */ + if (status != TX_SUCCESS) + { + + printf("Running Byte Memory Basic Test...................................... ERROR #3b\n"); + test_control_return(1); + } +} + + + +/* Define the test threads. */ + +static void thread_0_entry(ULONG thread_input) +{ + +UINT status; +CHAR *pointer_1; +CHAR *pointer_2; +CHAR *pointer_3; +CHAR *pointer_4; +INT i; +ULONG array[20]; +UCHAR *save_search; + + + /* Inform user. */ + printf("Running Byte Memory Basic Test...................................... "); + + /* Perform byte memory test. */ + byte_memory.first = 0x11223344; + byte_memory.second = 0x55667788; + byte_memory.first_middle = 0x21314151; + byte_memory.second_middle= 0x61718191; + byte_memory.next_to_last = 0x99aabbcc; + byte_memory.last = 0xddeeff00; + + /* Create the byte pool. */ + status = tx_byte_pool_create(&byte_memory.pool, "pool memory", &byte_memory.pool_area[0], (2048*sizeof(ULONG))/sizeof(ULONG)); + tx_byte_pool_delete(&byte_memory.pool); + + /* Check for status. */ + if ((status != TX_SUCCESS) || + (byte_memory.first != 0x11223344) || + (byte_memory.second != 0x55667788) || + (byte_memory.first_middle != 0x21314151) || + (byte_memory.second_middle != 0x61718191) || + (byte_memory.next_to_last != 0x99aabbcc) || + (byte_memory.last != 0xddeeff00)) + { + + /* Byte memory error. */ + printf("ERROR #4\n"); + test_control_return(1); + } + + /* Increment the run counter. */ + thread_0_counter++; + +#ifndef TX_DISABLE_ERROR_CHECKING + + /* Try to create a NULL pool. */ + pointer_1 = (CHAR *) 0x30000; + status = tx_byte_pool_create(TX_NULL, "pool 0", pointer_1, 108); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #5\n"); + test_control_return(1); + } + + /* Try to create the same pool. */ + status = tx_byte_pool_create(&pool_0, "pool 0", pointer_1, 108); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #6\n"); + test_control_return(1); + } + + /* Try to create a pool with a NULL start address. */ + status = tx_byte_pool_create(&pool_2, "pool 2", TX_NULL, 108); + + /* Check status. */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #7\n"); + test_control_return(1); + } + + /* Try to create a pool with a a bad size. */ + status = tx_byte_pool_create(&pool_2, "pool 2", pointer_1, 1); + + /* Check status. */ + if (status != TX_SIZE_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #8\n"); + test_control_return(1); + } + + /* Try to delete a byte pool with a NULL pointer. */ + status = tx_byte_pool_delete(TX_NULL); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #9\n"); + test_control_return(1); + } + + /* Try to delete a byte pool that hasn't been created. */ + pool_2.tx_byte_pool_id = 0; + status = tx_byte_pool_delete(&pool_2); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #10\n"); + test_control_return(1); + } + + /* Test NULL pool pointer. */ + status = tx_byte_allocate(TX_NULL, (VOID **) &pointer_1, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #11\n"); + test_control_return(1); + } + + /* Test non-created pool pointer. */ + pool_2.tx_byte_pool_id = 0; + status = tx_byte_allocate(&pool_2, (VOID **) &pointer_1, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_POOL_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #12\n"); + test_control_return(1); + } + + /* Test NULL memory pointer. */ + status = tx_byte_allocate(&pool_0, (VOID **) TX_NULL, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #13\n"); + test_control_return(1); + } + + /* Test extreme size. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_1, 240000, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SIZE_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #14\n"); + test_control_return(1); + } + + /* Test size of 0. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_1, 0, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SIZE_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #15\n"); + test_control_return(1); + } +#endif + + /* Test NULL pointer release. */ + status = tx_byte_release(TX_NULL); + + /* Check for error status! */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #16\n"); + test_control_return(1); + } + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_1, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #17\n"); + test_control_return(1); + } + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_2, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #18\n"); + test_control_return(1); + } + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_3, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #19\n"); + test_control_return(1); + } + + /* Attempt to allocate fourth area from the pool. This should fail because + there should be not enough bytes in the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_4, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_NO_MEMORY) + { + + /* Byte memory error. */ + printf("ERROR #20\n"); + test_control_return(1); + } + + /* Set the memory of all of the allocated memory. */ + for (i =0; i < 24; i++) + { + pointer_1[i] = (CHAR) 0xFF; + pointer_2[i] = (CHAR) 0xFF; + pointer_3[i] = (CHAR) 0xFF; + } + + /* Test the byte release with a bad block pointer. */ + status = _tx_byte_release(TX_NULL); + + /* Check for error status! */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #21\n"); + test_control_return(1); + } + + /* Test another bad block release... no pool pointer! */ + array[0] = 0; + array[1] = 0; + array[2] = 0; + status = _tx_byte_release(&array[2]); + + /* Check for error status! */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #22\n"); + test_control_return(1); + } + + /* Test another bad block release.... pool pointer is not a valid pool! */ + array[0] = 0; + array[1] = (ULONG) &array[3]; + array[2] = 0; + array[3] = 0; + status = _tx_byte_release(&array[2]); + + /* Check for error status! */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #22\n"); + test_control_return(1); + } + + /* Now release each of the blocks. */ + status = tx_byte_release(pointer_1); + + /* Check for status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #23\n"); + test_control_return(1); + } + + /* Now release the same block again. */ + status = tx_byte_release(pointer_1); + + /* Check for status. */ + if (status != TX_PTR_ERROR) + { + + /* Byte memory error. */ + printf("ERROR #24\n"); + test_control_return(1); + } + + /* Release the second memory area. */ + status = tx_byte_release(pointer_2); + + /* Check for status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #25\n"); + test_control_return(1); + } + + /* Release the third memory area. */ + status = tx_byte_release(pointer_3); + + /* Check for status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #26\n"); + test_control_return(1); + } + + /* Allocate each block again to make sure everything still + works. */ + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_1, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #27\n"); + test_control_return(1); + } + + /* Allocate second memory area from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_2, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #28\n"); + test_control_return(1); + } + + /* Allocate third memory area from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_3, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #29\n"); + test_control_return(1); + } + + /* Attempt to allocate fourth memory area from the pool. This should fail because + there should be not enough bytes in the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_4, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_NO_MEMORY) + { + + /* Byte memory error. */ + printf("ERROR #30\n"); + test_control_return(1); + } + + /* Now release each of the blocks. */ + status = tx_byte_release(pointer_1); + + /* Check for status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #31\n"); + test_control_return(1); + } + + /* Release the second memory area. */ + status = tx_byte_release(pointer_2); + + /* Check for status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #32\n"); + test_control_return(1); + } + + /* Release the third memory area. */ + status = tx_byte_release(pointer_3); + + /* Check for status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #33\n"); + test_control_return(1); + } + + /* Now allocate a block that should cause all of the blocks to merge + together. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_3, 88, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #34\n"); + test_control_return(1); + } + + /* Attempt to allocate fourth memory area from the pool. This should fail because + there should be not enough bytes in the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_4, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_NO_MEMORY) + { + + /* Byte memory error. */ + printf("ERROR #35\n"); + test_control_return(1); + } + + /* Release the block. */ + status = tx_byte_release(pointer_3); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #36\n"); + test_control_return(1); + } + + /* Now ensure the search pointer update in the byte search algorithm is updated. */ + + /* Allocate memory from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_1, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #37\n"); + test_control_return(1); + } + + /* Allocate second memory area from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_2, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #38\n"); + test_control_return(1); + } + + /* Allocate third memory area from the pool. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_3, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #39\n"); + test_control_return(1); + } + + /* Release the middle block. */ + status = tx_byte_release(pointer_2); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #40\n"); + test_control_return(1); + } + + /* Move the search pointer to the third block to exercise that code in the byte search algorithm. */ + pool_0.tx_byte_pool_search = (UCHAR *) pointer_3-8; + + /* Now allocate the block again. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_2, 24, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #41\n"); + test_control_return(1); + } + + /* Now release the blocks are test the merge with the update of the search pointer. */ + status = tx_byte_release(pointer_3); + status += tx_byte_release(pointer_2); + status += tx_byte_release(pointer_1); + + /* Move the search pointer to the third block to exercise that code in the byte search algorithm. */ + pool_0.tx_byte_pool_search = (UCHAR *) pointer_3-8; + + /* Allocate a large block to force the search pointer update. */ + status = tx_byte_allocate(&pool_0, (VOID **) &pointer_3, 88, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #42\n"); + test_control_return(1); + } + + +#ifndef TX_DISABLE_ERROR_CHECKING + + /* Create a timer for the test. */ + tx_timer_create(&timer_0, "timer 0", timer_entry, 0, 1, 1, TX_AUTO_ACTIVATE); + + /* Setup the ISR. */ + test_isr_dispatch = test_isr; + + /* Sleep for a bit... */ + tx_thread_sleep(3); + + /* Clear the ISR. */ + test_isr_dispatch = TX_NULL; + + /* Test for error. */ + if ((error) || (timer_executed != 1) || (isr_executed != 1)) + { + + /* Byte memory error. */ + printf("ERROR #43\n"); + test_control_return(1); + } + +#endif + + /* Delete both byte pools. */ + status = tx_byte_pool_delete(&pool_0); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #44\n"); + test_control_return(1); + } + + status = tx_byte_pool_delete(&pool_1); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #45\n"); + test_control_return(1); + } + + /* Delete pool 4. */ + status = tx_byte_pool_delete(&pool_4); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #46\n"); + test_control_return(1); + } + + /* Create pool 4. */ + status = tx_byte_pool_create(&pool_4, "pool 4", pool_4_memory, 300); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #47\n"); + test_control_return(1); + } + + /* Allocate three blocks... */ + status = tx_byte_allocate(&pool_4, (VOID **) &pointer_1, 84, TX_NO_WAIT); + status += tx_byte_allocate(&pool_4, (VOID **) &pointer_2, 84, TX_NO_WAIT); + status += tx_byte_allocate(&pool_4, (VOID **) &pointer_3, 84, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #48\n"); + test_control_return(1); + } + + /* At this point, there should be three allocated blocks and the reserved block at the end. */ + + /* Now release all the blocks in reverse order. This should leave the search pointer at the last block. */ + status = tx_byte_release(pointer_3); + save_search = pool_4.tx_byte_pool_search; + status += tx_byte_release(pointer_2); + status += tx_byte_release(pointer_1); + + /* Move the search pointer back to the last block. */ + pool_4.tx_byte_pool_search = save_search; + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #49\n"); + test_control_return(1); + } + + /* Now attempt to allocate a block that requires a merge, which should exercise the branch in byte search that does not + result in a search pointer change. */ + status = tx_byte_allocate(&pool_4, (VOID **) &pointer_1, 168, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #50\n"); + test_control_return(1); + } + + /* Release the last block. */ + status = tx_byte_release(pointer_1); + + /* Allocate all the blocks. */ + status = tx_byte_allocate(&pool_4, (VOID **) &pointer_1, 84, TX_NO_WAIT); + status += tx_byte_allocate(&pool_4, (VOID **) &pointer_2, 84, TX_NO_WAIT); + status += tx_byte_allocate(&pool_4, (VOID **) &pointer_3, 84, TX_NO_WAIT); + + /* Release all of the blocks in order. */ + status += tx_byte_release(pointer_1); + status += tx_byte_release(pointer_2); + status += tx_byte_release(pointer_3); + + /* Check status. */ + if (status != TX_SUCCESS) + { + + /* Byte memory error. */ + printf("ERROR #50\n"); + test_control_return(1); + } + + /* Now setup a special test to exercise the examine blocks equal to 0 path in the byte pool search. */ + pool_4.tx_byte_pool_search = save_search; + pool_4.tx_byte_pool_fragments = (UINT) (-1); + + /* Call byte allocate to execise the examine blocks equal to 0 path on non-merge block condition. */ + status = tx_byte_allocate(&pool_4, (VOID **) &pointer_1, 168, TX_NO_WAIT); + + /* Check status. */ + if (status != TX_NO_MEMORY) + { + + /* Byte memory error. */ + printf("ERROR #51\n"); + test_control_return(1); + } + + /* Successful test. */ + printf("SUCCESS!\n"); + test_control_return(0); +} + |