test_blockpool.cpp File Reference

#include <stk_config.h>
#include <stk.h>
#include <memory/stk_memory_blockpool.h>
#include <assert.h>
#include <string.h>
#include "stktest_context.h"

Include dependency graph for test_blockpool.cpp:

Go to the source code of this file.

Classes
class	stk::test::blockpool::TryAllocFreeTask< _AccessMode >
	Verifies TryAlloc returns a valid block, Free recycles it, and pool accounting stays consistent throughout. More...
class	stk::test::blockpool::ExhaustPoolTask< _AccessMode >
	Drains the entire pool via TryAlloc, verifies IsFull() and that a further TryAlloc returns nullptr, then frees every block. More...
class	stk::test::blockpool::BlockingAllocTask< _AccessMode >
	Task 0 holds all blocks; Task 1 blocks in Alloc(); Task 0 frees one block and verifies Task 1 unblocks and completes successfully. More...
class	stk::test::blockpool::TimedAllocTimeoutTask< _AccessMode >
	Task 0 holds all blocks; Task 1 calls TimedAlloc with a short timeout that must expire, returning nullptr within the expected window. More...
class	stk::test::blockpool::TimedAllocSuccessTask< _AccessMode >
	Task 0 holds all blocks; Task 1 calls TimedAlloc with a generous timeout; Task 0 frees a block before the timeout so Task 1 succeeds. More...
class	stk::test::blockpool::ConcurrentAllocFreeTask< _AccessMode >
	All tasks race to alloc a block, increment a shared counter inside the block, copy it out and free; total counter must equal iterations * tasks. More...
struct	stk::test::blockpool::TestRecord
class	stk::test::blockpool::TypedAllocTask< _AccessMode >
	Verifies that the typed wrappers AllocT<T>(), TryAllocT<T>(), and TimedAllocT<T>() return correctly typed pointers and that written fields are preserved until Free(). More...
class	stk::test::blockpool::FreeNullTask< _AccessMode >
	Ensures Free(nullptr) returns false and does not corrupt the pool. More...
class	stk::test::blockpool::AlignBlockSizeTask< _AccessMode >
	Verifies AlignBlockSize() rounds up to BLOCK_ALIGN multiples and never returns a value smaller than BLOCK_ALIGN. More...
class	stk::test::blockpool::StorageModeTask< _AccessMode >
	Creates a second pool using heap storage and verifies accessors report correct values for both storage modes. More...
class	stk::test::blockpool::StressTask< _AccessMode >
	All tasks hammer the pool with a mix of TryAlloc, blocking Alloc, and TimedAlloc operations; verifies the pool never leaks or deadlocks. More...

Namespaces
namespace	stk
	Namespace of STK package.
namespace	stk::test
	Namespace of the test inventory.
namespace	stk::test::blockpool
	Namespace of BlockMemoryPool test.

Macros
#define	_STK_POOL_TEST_TASKS_MAX   5
#define	_STK_POOL_TEST_TIMEOUT   1000
#define	_STK_POOL_TEST_SHORT_SLEEP   10
#define	_STK_POOL_TEST_LONG_SLEEP   100
#define	_STK_POOL_BLOCK_SIZE   32U
#define	_STK_POOL_CAPACITY   8U
#define	_STK_POOL_STACK_SIZE   256
#define	STK_TASK   static
#define	RUN(TestClass, name, param)

Functions
void	STK_ASSERT_HANDLER (const char *message, const char *file, int32_t line)
static void	stk::test::blockpool::ResetTestState ()
static bool	NeedsTwoTasks (const char *test_name)
static bool	NeedsAllTasks (const char *test_name)
template<class TaskType>
static int32_t	RunTest (const char *test_name, int32_t param=0)
int	main (int argc, char **argv)

Variables
static volatile int32_t	stk::test::blockpool::g_TestResult = 0
static volatile int32_t	stk::test::blockpool::g_InstancesDone = 0
static volatile int32_t	stk::test::blockpool::g_SharedCounter = 0
static Kernel< KERNEL_DYNAMIC|KERNEL_SYNC|(STK_TICKLESS_IDLE ? KERNEL_TICKLESS :0), 5, SwitchStrategyRR, PlatformDefault >	stk::test::blockpool::g_Kernel
static uint8_t	stk::test::blockpool::g_PoolStorage [8U *stk::memory::BlockMemoryPool::AlignBlockSize(32U)]
static stk::memory::BlockMemoryPool *	stk::test::blockpool::g_Pool = nullptr

Macro Definition Documentation

_STK_POOL_BLOCK_SIZE

#define _STK_POOL_BLOCK_SIZE   32U

Definition at line 27 of file test_blockpool.cpp.

Referenced by stk::test::blockpool::AlignBlockSizeTask< _AccessMode >::Run(), stk::test::blockpool::StressTask< _AccessMode >::Run(), stk::test::blockpool::TryAllocFreeTask< _AccessMode >::Run(), and RunTest().

_STK_POOL_CAPACITY

#define _STK_POOL_CAPACITY   8U

Definition at line 28 of file test_blockpool.cpp.

Referenced by stk::test::blockpool::BlockingAllocTask< _AccessMode >::Run(), stk::test::blockpool::ExhaustPoolTask< _AccessMode >::Run(), stk::test::blockpool::StorageModeTask< _AccessMode >::Run(), stk::test::blockpool::TimedAllocSuccessTask< _AccessMode >::Run(), stk::test::blockpool::TimedAllocTimeoutTask< _AccessMode >::Run(), stk::test::blockpool::TryAllocFreeTask< _AccessMode >::Run(), and RunTest().

_STK_POOL_STACK_SIZE

#define _STK_POOL_STACK_SIZE   256

Definition at line 33 of file test_blockpool.cpp.

_STK_POOL_TEST_LONG_SLEEP

#define _STK_POOL_TEST_LONG_SLEEP   100

Definition at line 26 of file test_blockpool.cpp.

Referenced by stk::test::blockpool::TimedAllocSuccessTask< _AccessMode >::Run().

_STK_POOL_TEST_SHORT_SLEEP

#define _STK_POOL_TEST_SHORT_SLEEP   10

Definition at line 25 of file test_blockpool.cpp.

Referenced by stk::test::blockpool::BlockingAllocTask< _AccessMode >::Run(), stk::test::blockpool::ConcurrentAllocFreeTask< _AccessMode >::Run(), stk::test::blockpool::StressTask< _AccessMode >::Run(), stk::test::blockpool::TimedAllocSuccessTask< _AccessMode >::Run(), and stk::test::blockpool::TimedAllocTimeoutTask< _AccessMode >::Run().

_STK_POOL_TEST_TASKS_MAX

#define _STK_POOL_TEST_TASKS_MAX   5

Definition at line 23 of file test_blockpool.cpp.

Referenced by stk::test::blockpool::ConcurrentAllocFreeTask< _AccessMode >::Run(), and stk::test::blockpool::StressTask< _AccessMode >::Run().

_STK_POOL_TEST_TIMEOUT

#define _STK_POOL_TEST_TIMEOUT   1000

Definition at line 24 of file test_blockpool.cpp.

RUN

#define RUN	(		TestClass,
			name,
			param )

Value:

    do { \
        if (RunTest<TestClass<ACCESS_PRIVILEGED>>(name, param) \
                != TestContext::SUCCESS_EXIT_CODE) \
            total_failures++; \
        else \
            total_success++; \
    } while (0)

Referenced by main().

STK_TASK

#define STK_TASK   static

Definition at line 34 of file test_blockpool.cpp.

Referenced by RunTest(), RunTest(), RunTest(), RunTest(), RunTest(), RunTest(), RunTest(), RunTest(), RunTest(), RunTest(), and RunTest().

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 811 of file test_blockpool.cpp.

{
    (void)argc;
    (void)argv;
 
    TestContext::ShowTestSuitePrologue();
 
    int total_failures = 0, total_success = 0;
 
    printf("--------------\n");
 
    stk::test::blockpool::g_Kernel.Initialize();
 
#define RUN(TestClass, name, param) \
    do { \
        if (RunTest<TestClass<ACCESS_PRIVILEGED>>(name, param) \
                != TestContext::SUCCESS_EXIT_CODE) \
            total_failures++; \
        else \
            total_success++; \
    } while (0)
 
#ifndef __ARM_ARCH_6M__
 
    // Test 1: TryAlloc / Free basic cycle
    RUN(stk::test::blockpool::TryAllocFreeTask,        "TryAllocFree",        0);
 
    // Test 2: Exhaust pool, verify IsFull, free all
    RUN(stk::test::blockpool::ExhaustPoolTask,         "ExhaustPool",         0);
 
    // Test 3: Blocking Alloc unblocked by Free from another task
    RUN(stk::test::blockpool::BlockingAllocTask,       "BlockingAlloc",       0);
 
    // Test 4: TimedAlloc expires when pool remains full
    RUN(stk::test::blockpool::TimedAllocTimeoutTask,   "TimedAllocTimeout",   0);
 
    // Test 5: TimedAlloc succeeds when block freed within timeout
    RUN(stk::test::blockpool::TimedAllocSuccessTask,   "TimedAllocSuccess",   0);
 
    // Test 6: Concurrent alloc/free counter integrity (20 iterations per task)
    RUN(stk::test::blockpool::ConcurrentAllocFreeTask, "ConcurrentAllocFree", 20);
 
    // Test 7: Typed helpers AllocT / TryAllocT / TimedAllocT
    RUN(stk::test::blockpool::TypedAllocTask,          "TypedAlloc",          0);
 
    // Test 8: Free(nullptr) is a safe no-op
    RUN(stk::test::blockpool::FreeNullTask,            "FreeNull",            0);
 
    // Test 9: AlignBlockSize static helper
    RUN(stk::test::blockpool::AlignBlockSizeTask,      "AlignBlockSize",      0);
 
    // Test 10: External vs heap storage constructors + accessors
    RUN(stk::test::blockpool::StorageModeTask,         "StorageMode",         0);
 
#endif // __ARM_ARCH_6M__
 
    // Test 11: Stress test (ARM Cortex-M0 compatible)
    RUN(stk::test::blockpool::StressTask, "Stress", 200);
 
#undef RUN
 
    int32_t final_result = (total_failures == 0
        ? TestContext::SUCCESS_EXIT_CODE
        : TestContext::DEFAULT_FAILURE_EXIT_CODE);
 
    printf("##############\n");
    printf("Total tests: %d\n", total_failures + total_success);
    printf("Failures: %d\n", (int)total_failures);
 
    TestContext::ShowTestSuiteEpilogue(final_result);
    return final_result;
}

References stk::test::TestContext::DEFAULT_FAILURE_EXIT_CODE, stk::test::blockpool::g_Kernel, RUN, stk::test::TestContext::ShowTestSuiteEpilogue(), stk::test::TestContext::ShowTestSuitePrologue(), and stk::test::TestContext::SUCCESS_EXIT_CODE.

Here is the call graph for this function:

NeedsAllTasks()

bool NeedsAllTasks ( const char * test_name )

static

Definition at line 740 of file test_blockpool.cpp.

{
    return (strcmp(test_name, "ConcurrentAllocFree") == 0) ||
           (strcmp(test_name, "Stress")              == 0);
}

Referenced by RunTest().

Here is the caller graph for this function:

NeedsTwoTasks()

bool NeedsTwoTasks ( const char * test_name )

static

Definition at line 726 of file test_blockpool.cpp.

{
    return (strcmp(test_name, "BlockingAlloc")      == 0) ||
           (strcmp(test_name, "TimedAllocTimeout")  == 0) ||
           (strcmp(test_name, "TimedAllocSuccess")  == 0) ||
           (strcmp(test_name, "ConcurrentAllocFree")== 0) ||
           (strcmp(test_name, "Stress")             == 0);
}

Referenced by RunTest().

Here is the caller graph for this function:

RunTest()

template<class TaskType>

int32_t RunTest ( const char * test_name, int32_t param = 0 )

static

Definition at line 754 of file test_blockpool.cpp.

{
    using namespace stk;
    using namespace stk::test;
    using namespace stk::test::blockpool;
 
    printf("Test: %s\n", test_name);
 
    ResetTestState();
 
    stk::memory::BlockMemoryPool pool(
        _STK_POOL_CAPACITY,
        _STK_POOL_BLOCK_SIZE,
        g_PoolStorage,
        sizeof(g_PoolStorage));
 
    g_Pool = &pool;
 
    STK_TASK TaskType task0(0, param);
    STK_TASK TaskType task1(1, param);
    TaskType task2(2, param);
    TaskType task3(3, param);
    TaskType task4(4, param);
 
    g_Kernel.AddTask(&task0);
 
    if (NeedsTwoTasks(test_name))
        g_Kernel.AddTask(&task1);
 
    if (NeedsAllTasks(test_name))
    {
        g_Kernel.AddTask(&task2);
        g_Kernel.AddTask(&task3);
        g_Kernel.AddTask(&task4);
    }
 
    g_Kernel.Start();
 
    g_Pool = nullptr;
 
    int32_t result = (g_TestResult
        ? TestContext::SUCCESS_EXIT_CODE
        : TestContext::DEFAULT_FAILURE_EXIT_CODE);
 
    printf("Result: %s\n", result == TestContext::SUCCESS_EXIT_CODE ? "PASS" : "FAIL");
    printf("--------------\n");
 
    return result;
}

References _STK_POOL_BLOCK_SIZE, _STK_POOL_CAPACITY, stk::memory::BlockMemoryPool(), stk::test::TestContext::DEFAULT_FAILURE_EXIT_CODE, stk::test::blockpool::g_Kernel, stk::test::blockpool::g_Pool, stk::test::blockpool::g_PoolStorage, stk::test::blockpool::g_TestResult, NeedsAllTasks(), NeedsTwoTasks(), stk::test::blockpool::ResetTestState(), STK_TASK, and stk::test::TestContext::SUCCESS_EXIT_CODE.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

STK_ASSERT_HANDLER()

void STK_ASSERT_HANDLER ( const char * message, const char * file, int32_t line )

extern

Definition at line 21 of file test_blockpool.cpp.

References STK_TEST_DECL_ASSERT.