Embedded/threadx
1
0
Fork 0
mirror of https://github.com/azure-rtos/threadx synced 2025-01-30 08:02:57 +08:00
Code Issues Releases Wiki Activity
threadx/test/smp/regression/threadx_byte_memory_basic_test.c
Tiejun Zhou ebeb02b958 Release ThreadX regression system
2023-04-04 09:40:54 +00:00

1065 lines
26 KiB
C
Raw Blame History

/* 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);
}
Reference in New Issue View Git Blame Copy Permalink