// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\personality\example\main.cpp

// Test code for example RTOS personality.

// 

//

#include <kernel/kern_priv.h>

#include <personality/example/personality.h>

#ifdef __cplusplus

extern "C" {

#endif

#define	OC_TASK				0

#define	L2_TASK				1

#define	RR_TASK				2

#define NONEXISTENT_TASK	3

#define TM_TASK				4

#define	TASK1				6

#define	TASK2				7

#define	TASK3				8

#define	TASK4				9

#define	L1_TASK				10

void oo_overall_control(void);

void l1_task_entry(void);

void l2_task_entry(void);

void rr_task_entry(void);

void tm_task_entry(void);

void task1_entry(void);

void task2_entry(void);

void task3_entry(void);

void task4_entry(void);

typedef void (*isr_entry)(unsigned);

extern int start_random_isr(isr_entry vector);

extern void stop_random_isr(void);

const taskinfo task_list[] =

	{

	/*		entry_pt,			priority, stack_size,	task_id, auto_start	*/

		{	&oo_overall_control,	120,	1024,		OC_TASK,	1	},

		{	&l2_task_entry,			236,	1024,		L2_TASK,	0	},

		{	&rr_task_entry,			224,	1024,		RR_TASK,	0	},

		{	&tm_task_entry,			240,	1024,		TM_TASK,	0	},

		{	&task1_entry,			112,	1024,		TASK1,		0	},

		{	&task2_entry,			112,	1024,		TASK2,		0	},

		{	&task3_entry,			112,	1024,		TASK3,		0	},

		{	&task4_entry,			112,	1024,		TASK4,		0	},

		{	&l1_task_entry,			244,	1024,		L1_TASK,	0	},

	/* terminator */

		{	0,						0,		0,			0,			0	}

	};

const poolinfo pool_list[] =

	{

	/*	block size,		block count	*/

		{	32,			256		},

		{	64,			256		},

		{	128,		128		},

		{	256,		64		},

		{	512,		32		},

	/* terminator */

		{	0,			0		}

	};

const int timer_count = 8;

const int semaphore_count = 2;

#define TM_TIMER		0

#define TM_INIT_DELAY	1000

#define TM_PERIOD		2

volatile unsigned next_random_id = 0;

volatile unsigned random_sem_signal_interval = 0;

volatile unsigned random_sem_signal_count = 0;

volatile unsigned random_send_interval = 0;

volatile unsigned random_send_count = 0;

volatile unsigned tmcount = 0;

volatile int t1func = 0;

volatile int t2func = 0;

volatile int t3func = 0;

volatile int t4func = 0;

#define TEST_SEM		0

#define	ISR_SEM			1

#define MSG_ID_INIT		1

#define MSG_ID_RUN		2

#define MSG_ID_RUN_P	3

#define	MSG_ID_RND_ISR	4

#define MSG_ID_DONE		5

#define	MSG_ID_DATA		6

#define	MSG_ID_FLUSH	7

#define MSG_ID_SEM_RPT	8

#define MSG_ID_RCV_RPT	9

#define MSG_ID_TM_RPT	10

typedef struct _run_msg

	{

	msghdr			header;

	int				task_id;

	unsigned		tmcount;

	int				parameter;

	} run_msg;

typedef struct _random_isr_msg

	{

	msghdr			header;

	unsigned		random_isr_number;

	unsigned		extra;

	} random_isr_msg;

typedef struct _data_msg

	{

	msghdr			header;

	int				length;

	unsigned char	checksum;

	unsigned char	data[1];

	} data_msg;

typedef struct _report_msg

	{

	msghdr			header;

	int				pad;

	unsigned		count;

	unsigned		ok_count;

	unsigned		bad_count;

	} report_msg;

void busy_wait(unsigned ticks)

	{

	unsigned t0 = tmcount;

	while ((tmcount - t0) < ticks)

		{}

	}

void send_run_signal()

	{

	run_msg* m = (run_msg*)alloc_mem_block(sizeof(run_msg));

	assert(m);

	m->header.msg_id = MSG_ID_RUN;

	m->task_id = current_task_id();

	m->tmcount = tmcount;

	int r = send_msg(OC_TASK, &m->header);

	assert(r == OK);

	}

void send_run_signal_p(int parameter)

	{

	run_msg* m = (run_msg*)alloc_mem_block(sizeof(run_msg));

	assert(m);

	m->header.msg_id = MSG_ID_RUN_P;

	m->task_id = current_task_id();

	m->tmcount = tmcount;

	m->parameter = parameter;

	int r = send_msg(OC_TASK, &m->header);

	assert(r == OK);

	}

void tsend_run_signal_p(int task_id, int parameter)

	{

	run_msg* m = (run_msg*)alloc_mem_block(sizeof(run_msg));

	assert(m);

	m->header.msg_id = MSG_ID_RUN_P;

	m->task_id = current_task_id();

	m->tmcount = tmcount;

	m->parameter = parameter;

	int r = send_msg(task_id, &m->header);

	assert(r == OK);

	}

void check_no_signal()

	{

	msghdr* m = NULL;

	int r = recv_msg(&m, NO_WAIT);

	assert(r == TIMED_OUT);

	}

unsigned check_for_signal(int task_id)

	{

	msghdr* m = NULL;

	int r = recv_msg(&m, NO_WAIT);

	assert(r == OK);

	assert(m->msg_id == MSG_ID_RUN);

	run_msg* rm = (run_msg*)m;

	assert(rm->task_id == task_id);

	unsigned tmc = rm->tmcount;

	free_mem_block(m);

	return tmc;

	}

int check_for_signal_p(int task_id, int task_id2, unsigned* pt)

	{

	msghdr* m = NULL;

	int r = recv_msg(&m, NO_WAIT);

	assert(r == OK);

	assert(m->msg_id == MSG_ID_RUN_P);

	run_msg* rm = (run_msg*)m;

	assert(rm->task_id == task_id);

	assert(m->sending_task_id == task_id2);

	r = rm->parameter;

	if (pt)

		*pt = rm->tmcount;

	free_mem_block(m);

	return r;

	}

int wait_for_signal_p(int task_id, unsigned* pt)

	{

	msghdr* m = NULL;

	int r = recv_msg(&m, WAIT_FOREVER);

	assert(r == OK);

	assert(m->msg_id == MSG_ID_RUN_P);

	run_msg* rm = (run_msg*)m;

	assert(rm->task_id == task_id);

	r = rm->parameter;

	if (pt)

		*pt = rm->tmcount;

	free_mem_block(m);

	return r;

	}

void resume_4(int t1, int t2, int t3, int t4)

	{

	if (t1>=0)

		assert(resume_task(t1)==OK);

	if (t2>=0)

		assert(resume_task(t2)==OK);

	if (t3>=0)

		assert(resume_task(t3)==OK);

	if (t4>=0)

		assert(resume_task(t4)==OK);

	}

void check_signal_4(int t1, int t2, int t3, int t4)

	{

	if (t1>=0)

		check_for_signal(t1);

	else

		check_no_signal();

	if (t2>=0)

		check_for_signal(t2);

	else

		check_no_signal();

	if (t3>=0)

		check_for_signal(t3);

	else

		check_no_signal();

	if (t4>=0)

		check_for_signal(t4);

	else

		check_no_signal();

	}

void check_for_multiple_signals(int task_id, int count)

	{

	unsigned t = check_for_signal(task_id);

	while (--count)

		{

		unsigned t2 = check_for_signal(task_id);

		assert(t2 - t >= 1);

		t = t2;

		}

	}

int flush_signals(void)

	{

	int c = 0;

	for (;;)

		{

		msghdr* m = NULL;

		int r = recv_msg(&m, NO_WAIT);

		if (r == TIMED_OUT)

			break;

		assert(r == OK);

		assert(m->msg_id == MSG_ID_RUN);

		free_mem_block(m);

		++c;

		}

	return c;

	}

void test_mem_pool(size_t size, int count, void** chain)

	{

	int i, fill;

	void *b, *bb, *c;

	c = *chain;

	for (i=0; i<count; ++i)

		{

		b = alloc_mem_block(size);

		assert(b != NULL);

		fill = (int)(size>>5);

		fill += 29;

		fill *= fill;

		fill &= 0xff;

		memset(b, fill, size);

		*(void**)b = c;

		((int*)b)[1] = (int)size;

		c = b;

		}

	bb = alloc_mem_block(size);

	assert(bb == NULL);

	*chain = c;

	}

void check_blocks(void* chain)

	{

	void* p = chain;

	while (p)

		{

		unsigned char *q, *qq;

		int size, fill, x;

		size = ((int*)p)[1];

		fill = (size>>5)+29;

		fill = (fill*fill)&0xff;

		q = (unsigned char*)p + sizeof(void*) + sizeof(int);

		qq = (unsigned char*)p + size;

		x = 0;

		while (q<qq)

			x |= (*q++ ^ fill);

		assert(x==0);

		p = *(void**)p;

		}

	}

int free_blocks(void* chain)

	{

	void* p = chain;

	int c = 0;

	while (p)

		{

		void* n = *(void**)p;

		free_mem_block(p);

		p = n;

		++c;

		}

	return c;

	}

void test_mem_mgr(void)

	{

	void* chain = NULL;

	const poolinfo* pi = pool_list;

	int nblocks = 0;

	int nfreed = 0;

	for (; pi->block_size; ++pi)

		{

		nblocks += pi->block_count;

		test_mem_pool(pi->block_size, pi->block_count, &chain);

		}

	check_blocks(chain);

	nfreed = free_blocks(chain);

	assert(nfreed == nblocks);

	chain = NULL;

	for (--pi; pi >= pool_list; --pi)

		test_mem_pool(pi->block_size, pi->block_count, &chain);

	check_blocks(chain);

	nfreed = free_blocks(chain);

	assert(nfreed == nblocks);

	chain = NULL;

	kprintf("Memory Manager Test OK");

	}

void test_suspend_1(void)

	{

	unsigned t1, t2, t3;

	int r;

	t1 = tmcount;

	delay(5*TM_PERIOD);

	t2 = tmcount;

	assert( ((int)t2)-((int)t1) >= 5 );

	r = suspend_task(TM_TASK);

	assert(r == OK);

	t1 = tmcount;

	delay(5*TM_PERIOD);

	t2 = tmcount;

	assert(t2==t1);

	r = resume_task(TM_TASK);

	assert(r == OK);

	t3 = tmcount;

	assert( ((int)t3)-((int)t2) >= 5 );

	r = suspend_task(TM_TASK);

	assert(r == OK);

	r = suspend_task(TM_TASK);

	assert(r == OK);

	t1 = tmcount;

	delay(5*TM_PERIOD);

	t2 = tmcount;

	assert(t2==t1);

	r = resume_task(TM_TASK);

	assert(r == OK);

	t3 = tmcount;

	assert(t3==t2);

	r = resume_task(TM_TASK);

	assert(r == OK);

	t3 = tmcount;

	assert( ((int)t3)-((int)t2) >= 5 );

	r = suspend_task(-1);

	assert(r == BAD_TASK_ID);

	r = suspend_task(300);

	assert(r == BAD_TASK_ID);

	r = suspend_task(NONEXISTENT_TASK);

	assert(r == BAD_TASK_ID);

	r = resume_task(-1);

	assert(r == BAD_TASK_ID);

	r = resume_task(300);

	assert(r == BAD_TASK_ID);

	r = resume_task(NONEXISTENT_TASK);

	assert(r == BAD_TASK_ID);

	kprintf("test_suspend_1 OK");

	}

void test_priority_scheduling(void)

	{

	int init_pri = get_task_priority(current_task_id());

	resume_4(TASK1, TASK2, TASK3, TASK4);

	delay(80*TM_PERIOD);

	check_for_multiple_signals(TASK1, 50);	// check no timeslicing

	assert(flush_signals()<=31);

	suspend_task(TASK1);

	delay(80*TM_PERIOD);

	check_for_multiple_signals(TASK2, 50);	// check no timeslicing

	assert(flush_signals()<=31);

	suspend_task(TASK2);

	delay(80*TM_PERIOD);

	check_for_multiple_signals(TASK3, 50);	// check no timeslicing

	assert(flush_signals()<=31);

	suspend_task(TASK3);

	delay(1);

	check_for_signal(TASK4);

	assert(flush_signals()<=1);

	t1func = 1;

	t2func = 1;

	t3func = 1;

	t4func = 1;

	resume_4(TASK1, TASK2, TASK3, TASK4);

	delay(10);

	flush_signals();

	resume_4(TASK3, TASK2, TASK4, TASK1);

	delay(10);

	check_signal_4(TASK3, TASK2, TASK4, TASK1);

	check_no_signal();

	resume_4(TASK1, TASK2, TASK3, TASK4);

	check_no_signal();	// all lower priority so don't run

	set_task_priority(TASK2, 255);		// higher than current task so run immediately

	check_for_signal(TASK2);

	set_task_priority(TASK4, 116);

	check_no_signal();	// all lower priority so don't run

	delay(10);

	check_for_signal(TASK4);

	check_for_signal(TASK1);

	check_for_signal(TASK3);

	set_task_priority(TASK1, 116);

	set_task_priority(TASK2, 116);

	set_task_priority(TASK3, 116);

	set_task_priority(TASK4, 116);

	resume_4(TASK1, TASK2, TASK3, TASK4);

	set_task_priority(current_task_id(), 112);	// drop current task priority

	assert(get_task_priority(current_task_id())==112);

	check_signal_4(TASK1, TASK2, TASK3, TASK4);

	set_task_priority(current_task_id(), init_pri);

	assert(get_task_priority(current_task_id())==init_pri);

	kprintf("test_priority_scheduling OK");

	}

unsigned sem_test(int task_id)

	{

	int r = semaphore_signal(TEST_SEM);

	assert(r==OK);

	return check_for_signal(task_id);

	}

unsigned sem_test_p(int task_id, int parameter)

	{

	unsigned t;

	int r = semaphore_signal(TEST_SEM);

	assert(r==OK);

	r = check_for_signal_p(task_id, task_id, &t);

	assert(r == parameter);

	return t;

	}

unsigned sem_test_pt(int task_id, int parameter)

	{

	unsigned t;

	int r = semaphore_signal(TEST_SEM);

	assert(r==OK);

	r = check_for_signal_p(task_id, task_id, &t);

	assert(r == parameter);

	return t;

	}

void test_semaphore(void)

	{

	unsigned t1, t2, t3;

	int r;

	int init_pri = get_task_priority(current_task_id());

	set_task_priority(TASK1, 128);

	set_task_priority(TASK2, 128);

	set_task_priority(TASK3, 128);

	set_task_priority(TASK4, 128);

	t1func = 2;

	t2func = 2;

	t3func = 2;