diff -r 000000000000 -r a41df078684a kerneltest/e32test/personality/example/main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/personality/example/main.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1104 @@
+// 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;
+	t4func = 2;
+	resume_4(TASK1, TASK2, TASK3, TASK4);
+	delay(10);		// let tasks wait on semaphore
+	check_no_signal();
+	sem_test(TASK1);	// test they are released in same order
+	sem_test(TASK2);
+	sem_test(TASK3);
+	sem_test(TASK4);
+	check_no_signal();
+	set_task_priority(TASK3, 132);	// test highest priority is released first
+	sem_test(TASK3);
+	sem_test(TASK3);
+	suspend_task(TASK3);		// test suspended task doesn't contend for semaphore
+	sem_test(TASK1);
+	sem_test(TASK2);
+	sem_test(TASK4);
+	sem_test(TASK1);
+	suspend_task(TASK2);
+	sem_test(TASK4);
+	sem_test(TASK1);
+	sem_test(TASK4);
+	set_task_priority(TASK2, 136);	// change priority while suspended
+	sem_test(TASK1);
+	sem_test(TASK4);
+	sem_test(TASK1);
+	resume_task(TASK2);
+	sem_test(TASK2);
+	sem_test(TASK2);	// test new highest priority task acquires semaphore first
+	delay(100*TM_PERIOD);
+	check_no_signal();	// check waits don't time out
+
+	t2func = 3;			// switch over to timed waits for task 2
+	t1 = sem_test(TASK2);			// get one last message of previous type
+	delay(5*TM_PERIOD);
+	t2 = sem_test_p(TASK2, OK);		// signal after half the timeout and check OK
+	delay(11*TM_PERIOD);			// wait for > timeout
+	r = check_for_signal_p(TASK2, TASK2, &t3);
+	assert(r == TIMED_OUT);
+	kprintf("t2-t1=%d t3-t2=%d", t2-t1, t3-t2);
+	assert(t2-t1 >= 5);
+	assert(t3-t2 >= 10);
+	sem_test_p(TASK2, OK);
+	resume_task(TASK3);
+
+	set_task_priority(current_task_id(), 176);	// raise current task priority
+	semaphore_signal(TEST_SEM);		// signal semaphore 4 times - should release all 4 waiting threads
+	semaphore_signal(TEST_SEM);
+	semaphore_signal(TEST_SEM);
+	semaphore_signal(TEST_SEM);
+	set_task_priority(current_task_id(), init_pri);	// let tasks run
+	r = check_for_signal_p(TASK2, TASK2, NULL);
+	assert(r == OK);
+	check_for_signal(TASK3);
+	check_for_signal(TASK4);
+	check_for_signal(TASK1);
+	set_task_priority(current_task_id(), 176);	// raise current task priority
+	busy_wait(11);					// let semaphore wait time out
+	t1func = 4;						// switch all threads over
+	t2func = 4;						//
+	t3func = 4;						//
+	t4func = 4;						//
+	semaphore_signal(TEST_SEM);		// signal semaphore 3 times - should release other 3 waiting threads
+	semaphore_signal(TEST_SEM);
+	semaphore_signal(TEST_SEM);
+	set_task_priority(current_task_id(), init_pri);	// let tasks run
+	r = check_for_signal_p(TASK2, TASK2, NULL);
+	assert(r == TIMED_OUT);
+	check_for_signal(TASK3);
+	check_for_signal(TASK4);
+	check_for_signal(TASK1);
+
+	kprintf("test_semaphore OK");
+	}
+
+void test_message_queue(void)
+	{
+	unsigned t1, t2, t3, t4;
+	int tid, p, r;
+	int init_pri = get_task_priority(current_task_id());
+	p = 0;
+	t1 = 0;
+	for (tid = TASK1; tid <= TASK4; ++tid)
+		{
+		for (p = 1; p; p<<=1)
+			{
+			tsend_run_signal_p(tid, p);
+			r = check_for_signal_p(OC_TASK, tid, NULL);
+			assert(r == p);
+			}
+		}
+	check_no_signal();
+	set_task_priority(current_task_id(), 176);	// raise current task priority
+	set_task_priority(TASK4, 144);	// change task priorities while they are waiting
+	set_task_priority(TASK3, 140);
+	set_task_priority(TASK2, 136);
+	set_task_priority(TASK1, 132);
+	t1func = 5;	// switch task 1 to timed waits
+	for (tid = TASK1; tid <= TASK4; ++tid)
+		{
+		for (p = 0; p<0x40000000; p+=(0x413b9cb+tid))
+			{
+			tsend_run_signal_p(tid, p);	// let multiple messages accumulate on the queues
+			}
+		}
+	check_no_signal();
+	set_task_priority(current_task_id(), init_pri);	// let tasks run
+	kprintf("init_pri=%d",init_pri);
+	for (tid = TASK4; tid >= TASK1; --tid)
+		{
+		for (p = 0; p<0x40000000; p+=(0x413b9cb+tid))
+			{
+			r = check_for_signal_p(OC_TASK, tid, &t1);
+			assert(r == p);
+			}
+		}
+
+	delay(5*TM_PERIOD);
+	tsend_run_signal_p(TASK1, p);		// send after half timeout
+	r = check_for_signal_p(OC_TASK, TASK1, &t2);
+	assert(r == p);
+	delay(11*TM_PERIOD);				// wait for > timeout
+	tsend_run_signal_p(TASK1, ~p);		// send after timeout
+	r = check_for_signal_p(TASK1, TASK1, &t3);
+	assert(r == TIMED_OUT);
+	kprintf("t2-t1=%d t3-t2=%d", t2-t1, t3-t2);
+	assert(t2-t1 >= 5);
+	assert(t3-t2 >= 10);
+	r = check_for_signal_p(OC_TASK, TASK1, &t4);
+	assert(r == ~p);
+	assert(t4-t3 <= 1);
+	t1func = 6;						// switch task 1 to timed semaphore wait
+	t2func = 7;						// switch task 2 to timed queue wait
+	t3func = 8;						//
+	t4func = 8;						//
+	for (tid = TASK1; tid <= TASK4; ++tid)
+		{
+		tsend_run_signal_p(tid, 0);
+		r = check_for_signal_p(OC_TASK, tid, NULL);
+		assert(r == 0);
+		}
+	check_no_signal();
+
+	kprintf("test_message_queue OK");
+	}
+
+void random_isr(unsigned n)
+	{
+	random_isr_msg* m;
+	unsigned extra = 1;
+	unsigned count = 1;
+	int r;
+	if (!(n%11))
+		++count;
+	if (!(n%13))
+		++count;
+	while (count--)
+		{
+		m = (random_isr_msg*)alloc_mem_block(sizeof(random_isr_msg));
+		m->header.msg_id = MSG_ID_RND_ISR;
+		m->random_isr_number = n;
+		extra *= n;
+		m->extra = extra;
+		r = send_msg(L1_TASK, &m->header);
+		}
+	if (random_sem_signal_count && !--random_sem_signal_count)
+		{
+		random_sem_signal_count = random_sem_signal_interval;
+		semaphore_signal(ISR_SEM);
+		}
+	}
+
+void flush_queue(msghdr** f, msghdr** l, msghdr* tm)
+	{
+	msghdr* m = *f;
+	*f = NULL;
+	*l = NULL;
+	send_to_epoc(tm);
+	while (m)
+		{
+		msghdr* n = m->next;
+		send_to_epoc(m);
+		m = n;
+		}
+	}
+
+void l1_task_entry(void)
+	{
+	msghdr* first = NULL;
+	msghdr* last = NULL;
+	unsigned state = 0;
+	unsigned extra_count = 0;
+	unsigned extra_value = 0;
+	assert(current_task_id() == L1_TASK);
+	kprintf("L1_TASK running");
+	for (;;)
+		{
+		msghdr* m = NULL;
+		int r = recv_msg(&m, WAIT_FOREVER);
+		assert(r == OK);
+		switch (m->msg_id)
+			{
+			case MSG_ID_RND_ISR:
+				{
+				random_isr_msg* rm = (random_isr_msg*)m;
+				assert(m->sending_task_id == TASK_ID_ISR);
+				assert(rm->random_isr_number == next_random_id);
+				if (state == 0)
+					{
+					extra_count = 0;
+					if (!(next_random_id % 11))
+						++extra_count;
+					if (!(next_random_id % 13))
+						++extra_count;
+					extra_value = next_random_id;
+					}
+				else if (state > 0)
+					{
+					extra_value *= next_random_id;
+					}
+				assert(rm->extra == extra_value);
+				if (++state > extra_count)
+					state = 0;
+				if (state == 0)
+					++next_random_id;
+				if (rm->random_isr_number == 0)
+					send_msg(OC_TASK, m), m=NULL;
+				if (state == 1 && extra_count == 2 && m)
+					{
+					flush_queue(&first, &last, m);
+					m = NULL;
+					}
+				if (random_send_count && !--random_send_count)
+					{
+					random_send_count = random_send_interval;
+					if (m)
+						send_msg(TASK2, m), m=NULL;
+					}
+				break;
+				}
+			case MSG_ID_DATA:
+				m->next = NULL;
+				if (last)
+					last->next = m;
+				else
+					first = m;
+				last = m;
+				m = NULL;
+				break;
+			case MSG_ID_FLUSH:
+				flush_queue(&first, &last, m);
+				m = NULL;
+				break;
+			default:
+				kprintf("L1<-%08x",m->msg_id);
+				break;
+			}
+		if (m)
+			free_mem_block(m);
+		}
+	}
+
+void l2_task_entry(void)
+	{
+	assert(current_task_id() == L2_TASK);
+	kprintf("L2_TASK running");
+	for (;;)
+		{
+		msghdr* m = NULL;
+		int r = recv_msg(&m, WAIT_FOREVER);
+		assert(r == OK);
+		switch (m->msg_id)
+			{
+			case MSG_ID_DATA:
+				{
+				data_msg* dm = (data_msg*)m;
+				int i;
+				unsigned char cs = 0;
+				for (i=0; i<dm->length; ++i)
+					cs = (unsigned char)(cs + dm->data[i]);
+				dm->checksum = cs;
+				send_msg(L1_TASK, m);
+				m=NULL;
+				break;
+				}
+			default:
+				kprintf("L2<-%08x",m->msg_id);
+				break;
+			}
+		if (m)
+			free_mem_block(m);
+		}
+	}
+
+void rr_task_entry(void)
+	{
+	assert(current_task_id() == RR_TASK);
+	kprintf("RR_TASK running");
+	for (;;)
+		{
+		msghdr* m = NULL;
+		int r = recv_msg(&m, WAIT_FOREVER);
+		assert(r == OK);
+		switch (m->msg_id)
+			{
+			case MSG_ID_DATA:
+				send_msg(L2_TASK, m);
+				m=NULL;
+				break;
+			default:
+				kprintf("RR<-%08x",m->msg_id);
+				break;
+			}
+		if (m)
+			free_mem_block(m);
+		}
+	}
+
+void tm_task_entry(void)
+	{
+	assert(current_task_id() == TM_TASK);
+	kprintf("TM_TASK running");
+	for (;;)
+		{
+		msghdr* m = NULL;
+		int r = recv_msg(&m, WAIT_FOREVER);
+		assert(r == OK);
+		switch (m->msg_id)
+			{
+			case MSG_ID_TIMEOUT:
+				tmcount = ((timer_msg*)m)->count;
+				assert(m->sending_task_id == TASK_ID_ISR);
+				if (!(tmcount & 255))
+					{
+					report_msg* rpt = (report_msg*)alloc_mem_block(sizeof(report_msg));
+					rpt->header.msg_id = MSG_ID_TM_RPT;
+					rpt->count = tmcount;
+					rpt->ok_count = 0;
+					rpt->bad_count = 0;
+					send_to_epoc(&rpt->header);
+					}
+				break;
+			default:
+				kprintf("TM<-%08x",m->msg_id);
+				break;
+			}
+		free_mem_block(m);
+		}
+	}
+
+void generic_task(volatile int* f)
+	{
+	int r;
+	msghdr* m;
+	unsigned t1, t2;
+	unsigned count = 0;
+	unsigned ok_count = 0;
+	unsigned bad_count = 0;
+	while (*f==0)
+		{
+		send_run_signal();
+		busy_wait(1);
+		}
+	while (*f==1)
+		{
+		send_run_signal();
+		suspend_task(current_task_id());
+		}
+	while (*f==2)
+		{
+		r = semaphore_wait(TEST_SEM, WAIT_FOREVER);
+		assert(r == OK);
+		send_run_signal();
+		}
+	while (*f==3)
+		{
+		r = semaphore_wait(TEST_SEM, 10*TM_PERIOD);
+		assert(r==OK || r==TIMED_OUT);
+		send_run_signal_p(r);
+		}
+	while (*f==4)
+		{
+		r = recv_msg(&m, WAIT_FOREVER);
+		assert(r==OK);
+		assert(m->sending_task_id == OC_TASK);
+		r = send_msg(OC_TASK, m);
+		assert(r == OK);
+		}
+	while (*f==5)
+		{
+		r = recv_msg(&m, 10*TM_PERIOD);
+		assert(r==OK || r==TIMED_OUT);
+		if (r == OK)
+			{
+			assert(m->sending_task_id == OC_TASK);
+			r = send_msg(OC_TASK, m);
+			assert(r == OK);
+			}
+		else
+			send_run_signal_p(r);
+		}
+	while (*f==6)
+		{
+		t1 = tick_count();
+		r = semaphore_wait(ISR_SEM, 5);
+		t2 = tick_count() - t1;
+		if (r == TIMED_OUT && t2<5)
+			{
+			kprintf("SEM timed out too soon: %d", t2);
+			++bad_count;
+			}
+		if (r == OK)
+			++ok_count;
+		++count;
+		if (!(count & 0xff))
+			{
+			report_msg* rpt = (report_msg*)alloc_mem_block(sizeof(report_msg));
+			rpt->header.msg_id = MSG_ID_SEM_RPT;
+			rpt->count = count;
+			rpt->ok_count = ok_count;
+			rpt->bad_count = bad_count;
+			send_to_epoc(&rpt->header);
+			}
+		}
+	while (*f==7)
+		{
+		t1 = tick_count();
+		r = recv_msg(&m, 5);
+		t2 = tick_count() - t1;
+		if (r == TIMED_OUT && t2<5)
+			{
+			kprintf("RECV timed out too soon: %d", t2);
+			++bad_count;
+			}
+		if (r==OK)
+			++ok_count, free_mem_block(m);
+		++count;
+		if (!(count & 0xff))
+			{
+			report_msg* rpt = (report_msg*)alloc_mem_block(sizeof(report_msg));
+			rpt->header.msg_id = MSG_ID_RCV_RPT;
+			rpt->count = count;
+			rpt->ok_count = ok_count;
+			rpt->bad_count = bad_count;
+			send_to_epoc(&rpt->header);
+			}
+		}
+	kprintf("Task %d finished", current_task_id());
+	for(;;)
+		suspend_task(current_task_id());
+	}
+
+void task1_entry(void)
+	{
+	assert(current_task_id() == TASK1);
+	generic_task(&t1func);
+	}
+
+void task2_entry(void)
+	{
+	assert(current_task_id() == TASK2);
+	generic_task(&t2func);
+	}
+
+void task3_entry(void)
+	{
+	assert(current_task_id() == TASK3);
+	generic_task(&t3func);
+	}
+
+void task4_entry(void)
+	{
+	assert(current_task_id() == TASK4);
+	generic_task(&t4func);
+	}
+
+
+
+void oo_overall_control(void)
+	{
+	int r;
+	msghdr* m;
+	random_isr_msg* rm;
+	unsigned t1, t2, rss_interval;
+	kprintf("OC_TASK running");
+	assert(current_task_id() == OC_TASK);
+	resume_task(L2_TASK);
+	resume_task(RR_TASK);
+	resume_task(TM_TASK);
+	test_mem_mgr();
+
+	kprintf("Wait for init msg");
+	r = recv_msg(&m, WAIT_FOREVER);
+	assert(r == OK);
+	assert(m->msg_id == MSG_ID_INIT);
+	assert(m->sending_task_id == TASK_ID_UNKNOWN);
+	free_mem_block(m);
+	kprintf("Received init msg");
+
+	r = start_periodic_timer(TM_TIMER, TM_TASK, TM_INIT_DELAY, TM_PERIOD, NULL);
+	assert(r == OK);
+	delay(TM_INIT_DELAY-10);
+	assert(tmcount == 0);
+	delay(10*TM_PERIOD+20);
+	assert(tmcount > 0);
+	test_suspend_1();
+	test_priority_scheduling();
+	test_semaphore();
+	test_message_queue();
+
+	resume_task(L1_TASK);
+	r = start_random_isr(&random_isr);
+	if (r != OK)
+		goto no_random_isr;
+
+	r = recv_msg(&m, WAIT_FOREVER);
+	assert(r == OK);
+	assert(m->msg_id == MSG_ID_RND_ISR);
+	assert(m->sending_task_id == L1_TASK);
+	rm = (random_isr_msg*)m;
+	assert(rm->random_isr_number == 0);
+	free_mem_block(m);
+	t1 = next_random_id;
+	delay(1024);
+	t2 = next_random_id;
+	kprintf("%d random ISRs in 1024 ticks", t2-t1);
+	rss_interval = (5*(t2-t1)+512)/1024;
+	set_task_priority(TASK1, 196);	// needs to be higher than DfcThread1
+	set_task_priority(TASK2, 196);
+	random_sem_signal_interval = rss_interval;
+	random_sem_signal_count = rss_interval;
+	random_send_interval = rss_interval;
+	random_send_count = rss_interval;
+
+no_random_isr:
+	m = (msghdr*)alloc_mem_block(sizeof(msghdr));
+	m->msg_id = MSG_ID_DONE;
+	send_to_epoc(m);
+	kprintf("All tests completed OK");
+	for (;;)
+		{
+		int r = recv_msg(&m, WAIT_FOREVER);
+		assert(r == OK);
+		switch (m->msg_id)
+			{
+			case MSG_ID_DATA:
+				send_msg(RR_TASK, m);
+				m=NULL;
+				break;
+			case MSG_ID_FLUSH:
+				send_msg(L1_TASK, m);
+				m=NULL;
+				break;
+			case MSG_ID_DONE:
+				stop_random_isr();
+				stop_timer(TM_TIMER);
+				suspend_task(L1_TASK);
+				suspend_task(L2_TASK);
+				suspend_task(RR_TASK);
+				suspend_task(TM_TASK);
+				suspend_task(TASK1);
+				suspend_task(TASK2);
+				suspend_task(TASK3);
+				suspend_task(TASK4);
+				break;
+			default:
+				kprintf("OC<-%08x",m->msg_id);
+				break;
+			}
+		if (m)
+			free_mem_block(m);
+		}
+	}
+
+#ifdef __cplusplus
+}
+#endif