BOOL cg_mutex_delete(CgMutex *mutex)
{
if (!mutex)
return FALSE;
cg_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
CloseHandle(mutex->mutexID);
#elif defined(BTRON)
del_sem(mutex->mutexID);
#elif defined(ITRON)
del_sem(mutex->mutexID);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_del_sem(mutex->mutexID);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_del_sem(mutex->mutexID);
#else
pthread_mutex_destroy(&mutex->mutexID);
#endif
free(mutex);
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
bool mupnp_mutex_delete(mUpnpMutex *mutex)
{
if (!mutex)
return false;
mupnp_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
CloseHandle(mutex->mutexID);
#elif defined(BTRON)
del_sem(mutex->mutexID);
#elif defined(ITRON)
del_sem(mutex->mutexID);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_del_sem(mutex->mutexID);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_del_sem(mutex->mutexID);
#else
pthread_mutex_destroy(&mutex->mutexID);
#endif
free(mutex);
mupnp_log_debug_l4("Leaving...\n");
return true;
}
int main()
{
void *shared_memory = NULL;
struct shm_buff *shm_buff_inst;
char buffer[BUFSIZ];
int shmid,semid;
ignore_signal();
semid = semget(ftok(".",'a'),1,0666|IPC_CREAT);
init_sem(semid,1);
shmid = shmget(ftok(".",'b'),sizeof(struct shm_buff),0666|IPC_CREAT);
if(shmid == -1)
{
perror("shmget failed");
del_sem(semid);
exit(1);
}
shared_memory=shmat(shmid,(void*)0,0);
if(shared_memory==(void*)-1)
{
perror("shmat");
del_sem(semid);
exit(1);
}
printf("memory attached at %X\n",(int)shared_memory);
shm_buff_inst = (struct shm_buff*)shared_memory;
do
{
sem_p(semid);
printf("enter some text to the shared memory(enter'quit'to exit):");
if(fgets(shm_buff_inst->buffer,SHM_BUFF_SZ,stdin)==NULL)
{
perror("fgets");
sem_v(semid);
break;
}
shm_buff_inst->pid=getpid();
sem_v(semid);
} while(strncmp(shm_buff_inst->buffer,"quit",4)!=0);
del_sem(semid);
if(shmdt(shared_memory)==1)
{
perror("shmdt");
exit(1);
}
exit(0);
}
//void sys_sem_free(sys_sem_t *sem) {}
void sys_sem_free(sys_sem_t *sem) {
ER ercd;
ercd = del_sem(sem->id);
if (ercd != E_OK) {
error("Error with ercd=%d in sys_sem_free.\n", ercd);
}
syslog(LOG_DEBUG, "The semaphore (ID=%d) was deleted.", sem->id);
}
int sthread_cond_destroy(sthread_cond_t *cond)
{
if(cond->cond) {
del_sem(cond->cond->locks, 0);
mvshared_free(cond->cond);
return 0;
}
return -1;
}
int sthread_barrier_destroy(sthread_barrier_t *barrier)
{
if(barrier->barrier) {
del_sem(barrier->barrier->sema, 0);
mvshared_free(barrier->barrier);
return 0;
}
return -1;
}
int main(void)
{
int semid = -1;
int pid = -1;
/*1.申请信号量 */
semid = semget(ftok(".", 'b'), 1, IPC_CREAT|0666);
if(semid < 0) {
perror("semget error");
exit(1);
}
/* 2.初始化信号量 */
init_sem(semid, 0, 1); //资源初始化成可用
/*创建子进程 */
if( (pid = fork()) <0) {
perror("fork");
exit(1);
}
if(pid >0) { //父进程
sem_p(semid, 0, 1); //P操作
//操作资源
//...
sem_v(semid, 0, 1); //V操作
} else { //子进程
sem_p(semid, 0, 1); //P操作
//操作资源
//...
sem_v(semid, 0, 1); //V操作
//删除信号量
del_sem(semid);
}
return 0;
}
/*
******************************************************************************
* dgadmin_rest_sync_init -- *//**
*
* \brief This routine creates sync task and resource.
*
* \retval 0 Success
* \retval >0 Failure
*
*****************************************************************************/
dove_status dgadmin_rest_sync_init(void)
{
dove_status retval = DOVE_STATUS_OK;
if (create_sem("RSSEM", 0, 0, &gDgwySyncSemId) != OSW_OK)
{
printf("Failed to create semaphore \n");
retval = DOVE_STATUS_ERROR;
goto init_exit;
}
/* Create the system task */
if (create_task("RSTASK", 10,
OSW_DEFAULT_STACK_SIZE,
(task_entry) dgadmin_rest_sync_main,
0, &gDgwySyncTaskId) != OSW_OK)
{
printf("Failed to create task \n");
goto init_failed;
}
if (sem_take(gDgwySyncSemId) != OSW_OK)
{
retval = DOVE_STATUS_ERROR;
goto init_failed;
}
else
{
goto init_exit;
}
init_failed:
del_sem(gDgwySyncSemId);
init_exit:
return retval;
}
int FreeMutex(wolfSSL_Mutex* m)
{
del_sem( m->id );
return 0;
}
int main()
{
key_t key;
int shmid, semid, msqid;
char *shm;
char data[] = "this is server";
struct shmid_ds buf1; /*用于删除共享内存*/
struct msqid_ds buf2; /*用于删除消息队列*/
struct msg_form msg; /*消息队列用于通知对方更新了共享内存*/
// 获取key值
if((key = ftok(".", 'z')) < 0)
{
perror("ftok error");
exit(1);
}
// 创建共享内存
if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1)
{
perror("Create Shared Memory Error");
exit(1);
}
// 连接共享内存
shm = (char*)shmat(shmid, 0, 0);
if((int)shm == -1)
{
perror("Attach Shared Memory Error");
exit(1);
}
// 创建消息队列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
{
perror("msgget error");
exit(1);
}
// 创建信号量
semid = creat_sem(key);
// 读数据
while(1)
{
msgrcv(msqid, &msg, 1, 888, 0); /*读取类型为888的消息*/
if(msg.mtext == 'q') /*quit - 跳出循环*/
break;
if(msg.mtext == 'r') /*read - 读共享内存*/
{
sem_p(semid);
printf("%s\n",shm);
sem_v(semid);
}
}
// 断开连接
shmdt(shm);
/*删除共享内存、消息队列、信号量*/
shmctl(shmid, IPC_RMID, &buf1);
msgctl(msqid, IPC_RMID, &buf2);
del_sem(semid);
return 0;
}
static ER _dmloader_rmv_ldm(ID ldm_can_id) {
// TODO: hard coded & should check ldm_can status
if (ldm_can_id != 1) return E_ID;
T_LDM_CAN *ldm_can = &ldm_cans[ldm_can_id - 1];
ER ercd;
ercd = loc_mtx(DMLOADER_MTX);
if(ercd != E_OK) {
syslog(LOG_ERROR, "%s(): Acquire mutex failed.", __FUNCTION__);
goto error_exit;
}
if (ldm_can->status != LDM_CAN_RUNNING) {
syslog(LOG_ERROR, "%s(): LDM container is not running.", __FUNCTION__);
ercd = E_OBJ;
goto error_exit;
}
// Destroy all EV3CYCs
destroy_all_ev3cyc();
// Deletion
for(SIZE i = 0; i < ldm_can->cfg_entry_num && ercd == E_OK; ++i) {
MOD_CFG_ENTRY *ent = &ldm_can->cfg_table[i];
switch(ent->sfncd) {
case TSFN_CRE_TSK: {
syslog(LOG_DEBUG, "%s(): RMV MOD_CFG_ENTRY TSFN_CRE_TSK", __FUNCTION__);
ID tskid = *(ID*)ent->retvalptr;
ter_tsk(tskid);
ercd = del_tsk(tskid);
assert(ercd == E_OK);
break; }
case TSFN_CRE_SEM: {
syslog(LOG_DEBUG, "%s(): RMV MOD_CFG_ENTRY TSFN_CRE_SEM", __FUNCTION__);
ID semid = *(ID*)ent->retvalptr;
ercd = del_sem(semid);
assert(ercd == E_OK);
break; }
case TSFN_CRE_FLG: {
syslog(LOG_DEBUG, "%s(): RMV MOD_CFG_ENTRY TSFN_CRE_FLG", __FUNCTION__);
ID flgid = *(ID*)ent->retvalptr;
ercd = del_flg(flgid);
assert(ercd == E_OK);
break; }
default:
syslog(LOG_ERROR, "%s(): Unsupported static function code %d.", __FUNCTION__, ent->sfncd);
ercd = E_OBJ;
goto error_exit;
}
}
ldm_can->status = LDM_CAN_FREE;
// TODO: clean ldm_can
error_exit:
unl_mtx(DMLOADER_MTX);
return ercd;
}
int OptLogInit()
{
int ret;
int cfglen;
int i;
int j;
setlinebuf(stdout);
EngModePrintOn=0;
ST_OptLogCfgData sval;
ST_OptLogCfgInfo *cfginf = NULL;
bzero(&sval,sizeof(sval));
Debug_print("%s\n",CONFIG_FILE);
if (gendata.initlized)
{
Debug_print("The operation log has been initlized ,can not init again\n");
return 0;
}
ret = ReadCfg(CONFIG_FILE,&cfginf,&cfglen);
if (ret < 0)
{
printf("read configuration file failed, use default set\n");
sval.curlevel = 3;
sval.enflags |= PrtAllComp;
if (!getcwd(sval.rcdpath,PATHLEN))
{
perror("get current directory failed");
return -1;
}
}
for (i=0;i<cfglen;i++)
{
Debug_print("key:%s\t val:%s\n",cfginf[i].key,cfginf[i].val);
if (!strcmp(cfginf[i].key,"prtlevel")&&cfginf[i].val[0]!='0')
{
sval.enflags |= EnLevel;
continue;
}
if (!strcmp(cfginf[i].key,"prtfilename")&&cfginf[i].val[0]!='0')
{
sval.enflags|= EnFName;
continue;
}
if (!strcmp(cfginf[i].key,"prtfuncname")&&cfginf[i].val[0]!='0')
{
sval.enflags|= EnFcName;
continue;
}
if (!strcmp(cfginf[i].key,"prtlinenum")&&cfginf[i].val[0]!='0')
{
sval.enflags|= EnLine;
continue;
}
if (!strcmp(cfginf[i].key,"prttime")&&cfginf[i].val[0]!='0')
{
sval.enflags|= EnTime;
continue;
}
if (!strcmp(cfginf[i].key,"prtinfile")&&cfginf[i].val[0]!='0')
{
sval.enflags|= EnFRcd;
continue;
}
if (!strcmp(cfginf[i].key,"recordpath")&&cfginf[i].val[0]!=0)
{
int slen;
slen = strlen(cfginf[i].val);
if (cfginf[i].val[slen-1] == '/')
{
cfginf[i].val[slen-1] = 0;
}
strncpy(sval.rcdpath,cfginf[i].val,PATHLEN);
continue;
}
if (!strcmp(cfginf[i].key,"level")&&cfginf[i].val[0]!=0)
{
sval.curlevel = atoi(cfginf[i].val);
continue;
}
if (!strcmp(cfginf[i].key,"componentlist")&&cfginf[i].val[0]!=0)
{
if (GetComps(cfginf[i].val,&sval) < 0)
{
Debug_print("get components list failed\n");
}
else
{
for (j=0;j<sval.compnum;j++)
Debug_print("component name:%s\n",sval.comp[j]);
}
continue;
}
}
if (cfginf)
{
free(cfginf);
}
Debug_print("enflag:%x\tpath:%s\n",sval.enflags,sval.rcdpath);
//create shared memory and init semaphore
gendata.shmid = shmget(IPC_KEY,sizeof(ST_OptLogCfgData),0666);
if (gendata.shmid == -1)
{
Debug_print("shared memory does not exist,need create\n");
gendata.shmid = shmget(IPC_KEY,sizeof(ST_OptLogCfgData),0666|IPC_CREAT);
if (gendata.shmid < 0)
{
perror("create shared memory failed");
return -1;
}
Debug_print("create shared memory success\n");
}
else
{
sval.enflags |= SMemExist;
}
Debug_print("get shared memory success\n");
gendata.cfg = (ST_OptLogCfgData *)shmat(gendata.shmid,NULL,0);
if (gendata.cfg == (void *)-1)
{
perror("get shared memory address failed");
shmctl(gendata.shmid,IPC_RMID,NULL);
gendata.cfg = NULL;
return -1;
}
//bzero(gendata.cfg,4096*65);
Debug_print("get shared memory address success\n");
gendata.semid = semget(SEM_KEY,0,0666);
if (gendata.semid < 0)
{
Debug_print("semaphore is not created, need create\n");
gendata.semid = semget(SEM_KEY,1,0666|IPC_CREAT);
if (gendata.semid < 0)
{
perror("create semaphore failed");
return -1;
}
Debug_print("create semaphore success\n");
if (init_sem(gendata.semid,1) < 0)
{
printf("init semaphore failed\n");
del_sem(gendata.semid);
return -1;
}
Debug_print("init semaphore success\n");
}
Debug_print("get semaphore success\n");
if(pthread_mutex_init(&gendata.filemutex,NULL) != 0)
{
perror("create file mutex failed");
return -1;
}
if(pthread_mutex_init(&gendata.pathmutex,NULL) != 0)
{
perror("create path mutex failed");
return -1;
}
#ifdef READ_CFG
if (1)
#else
if (!(sval.enflags&SMemExist))
#endif
{
Debug_print("shared memory does not exists need to set value to memory\n");
Debug_print("curlevel:%d\trcdpath:%s\tcomnum:%d\tenflags:%x\n",sval.curlevel,\
sval.rcdpath,sval.compnum,sval.enflags);
OptLogSet(&sval);
}
gendata.initlized = 1;
return 0;
}
static int __ui_del_sem(struct pt_regs *regs)
{
ID semid = __xn_reg_arg1(regs);
return del_sem(semid);
}
void task2( unsigned int arg )
{
ER ercd;
int i;
CYG_TEST_INFO( "Task 2 running" );
ercd = get_tid( &i );
CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
CYG_TEST_CHECK( 2 == i, "tid not 2" );
if ( 22222 != arg )
CYG_TEST_FAIL( "Task 2 arg not 22222" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
ercd = del_sem( 1 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_sem( 2 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_sem( 1 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_sem( 2 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
ercd = del_flg( 1 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_flg( 2 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_flg( 1 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_flg( 2 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
ercd = del_mbx( 1 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_mbx( 2 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_mbx( 1 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
ercd = del_mbx( 2 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
ercd = slp_tsk();
CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE
// we expect task2 to be killed here
CYG_TEST_FAIL( "Task 2 ran to completion!" );
}
void task1( unsigned int arg )
{
ER ercd;
int tests = 0;
CYG_TEST_INFO( "Task 1 running" );
ercd = dis_dsp();
CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
ercd = sta_tsk( 2, 22222 );
CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" );
ercd = chg_pri( 2, 5 );
CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" );
ercd = ena_dsp();
CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
ercd = dly_tsk( 10 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
#ifdef CYGPKG_UITRON_SEMAS_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_sem( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" );
ercd = del_sem( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_sem bad ercd !E_ID" );
ercd = cre_sem( -6, &t_csem );
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" );
ercd = cre_sem( 99, &t_csem );
CYG_TEST_CHECK( E_ID == ercd, "cre_sem bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_sem bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_sem bad ercd" );
// check it is deleted
ercd = sig_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = preq_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "preq_sem bad ercd !E_NOEXS" );
ercd = twai_sem( 3, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_sem bad ercd !E_NOEXS" );
ercd = wai_sem( 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_sem bad ercd !E_NOEXS" );
ercd = ref_sem( &t_rsem, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_sem bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_sem( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" );
#endif
ercd = cre_sem( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_sem bad ercd !E_PAR" );
t_csem.sematr = 0xfff;
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_sem bad ercd !E_RSATR" );
t_csem.sematr = 0;
#endif // we can test bad param error returns
ercd = cre_sem( 3, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
// and check we can use it
ercd = sig_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" );
ercd = wai_sem( 3 );
CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" );
ercd = preq_sem( 3 );
CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" );
ercd = twai_sem( 3, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" );
ercd = ref_sem( &t_rsem, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_sem( 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" );
// check they are deleted
ercd = sig_sem( 1 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = sig_sem( 2 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
// re-create and do it again
ercd = cre_sem( 1, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
ercd = cre_sem( 2, &t_csem );
CYG_TEST_CHECK( E_OK == ercd, "cre_sem bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_sem( 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_sem bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_sem( 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_sem bad ercd !E_DLT" );
// check they are deleted
ercd = sig_sem( 1 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
ercd = sig_sem( 2 );
CYG_TEST_CHECK( E_NOEXS == ercd, "sig_sem bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete semaphores");
#endif // CYGPKG_UITRON_SEMAS_CREATE_DELETE
#ifdef CYGPKG_UITRON_FLAGS_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_flg( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" );
ercd = del_flg( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_flg bad ercd !E_ID" );
ercd = cre_flg( -6, &t_cflg );
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" );
ercd = cre_flg( 99, &t_cflg );
CYG_TEST_CHECK( E_ID == ercd, "cre_flg bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_flg bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_flg( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
// check it is deleted
ercd = set_flg( 3, 0x6789 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
ercd = clr_flg( 3, 0x9876 );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
ercd = pol_flg( &scratch, 3, 0xdddd, TWF_ANDW );
CYG_TEST_CHECK( E_NOEXS == ercd, "pol_flg bad ercd !E_NOEXS" );
ercd = twai_flg( &scratch, 3, 0x4444, TWF_ORW, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "twai_flg bad ercd !E_NOEXS" );
ercd = wai_flg( &scratch, 3, 0xbbbb, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_NOEXS == ercd, "wai_flg bad ercd !E_NOEXS" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_flg bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_flg( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" );
#endif
ercd = cre_flg( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_flg bad ercd !E_PAR" );
t_cflg.flgatr = 0xfff;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_flg bad ercd !E_RSATR" );
#endif // we can test bad param error returns
// now create it well
t_cflg.flgatr = 0;
t_cflg.iflgptn = 0;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// and check we can use it
ercd = clr_flg( 3, 0x7256 );
CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" );
ercd = set_flg( 3, 0xff );
CYG_TEST_CHECK( E_OK == ercd, "set_flg bad ercd" );
ercd = wai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR );
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
ercd = twai_flg( &scratch, 3, 0xaa, TWF_ANDW | TWF_CLR, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" );
// now create it again with a preset pattern and check that we can
// detect that pattern:
ercd = del_flg( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_flg bad ercd" );
t_cflg.flgatr = 0;
t_cflg.iflgptn = 0x1234;
ercd = cre_flg( 3, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// and check we can use it
ercd = wai_flg( &scratch, 3, 0x1200, TWF_ANDW );
CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0x0034, TWF_ANDW );
CYG_TEST_CHECK( E_OK == ercd, "pol_flg bad ercd" );
ercd = twai_flg( &scratch, 3, 0x1004, TWF_ANDW, 10 );
CYG_TEST_CHECK( E_OK == ercd, "twai_flg bad ercd" );
ercd = pol_flg( &scratch, 3, 0xffedcb, TWF_ORW );
CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0x1234 == t_rflg.flgptn, "ref_flg bad ercd" );
ercd = clr_flg( 3, 0 );
ercd = ref_flg( &t_rflg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" );
CYG_TEST_CHECK( 0 == t_rflg.flgptn, "ref_flg bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_flg( &scratch, 1, 0xaa, TWF_ANDW );
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_flg( &scratch, 2, 0x55, TWF_ANDW, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" );
// check they are deleted
ercd = set_flg( 1, 0x22 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
ercd = clr_flg( 2, 0xdd );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
// re-create and do it again
t_cflg.iflgptn = 0x5555;
ercd = cre_flg( 1, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
t_cflg.iflgptn = 0;
ercd = cre_flg( 2, &t_cflg );
CYG_TEST_CHECK( E_OK == ercd, "cre_flg bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = wai_flg( &scratch, 1, 0xaaaa, TWF_ORW | TWF_CLR );
CYG_TEST_CHECK( E_DLT == ercd, "wai_flg bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = twai_flg( &scratch, 2, 0xffff, TWF_ORW, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_flg bad ercd !E_DLT" );
// check they are deleted
ercd = clr_flg( 1, 0xd00d );
CYG_TEST_CHECK( E_NOEXS == ercd, "clr_flg bad ercd !E_NOEXS" );
ercd = set_flg( 2, 0xfff00 );
CYG_TEST_CHECK( E_NOEXS == ercd, "set_flg bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete flags");
#endif // CYGPKG_UITRON_FLAGS_CREATE_DELETE
#ifdef CYGPKG_UITRON_MBOXES_CREATE_DELETE
tests++;
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
ercd = del_mbx( -6 );
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" );
ercd = del_mbx( 99 );
CYG_TEST_CHECK( E_ID == ercd, "del_mbx bad ercd !E_ID" );
ercd = cre_mbx( -6, &t_cmbx );
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );
ercd = cre_mbx( 99, &t_cmbx );
CYG_TEST_CHECK( E_ID == ercd, "cre_mbx bad ercd !E_ID" );
#endif // we can test bad param error returns
// try a pre-existing object
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_OBJ == ercd, "cre_mbx bad ercd !E_OBJ" );
// delete it so we can play
ercd = del_mbx( 3 );
CYG_TEST_CHECK( E_OK == ercd, "del_mbx bad ercd" );
// check it is deleted
ercd = snd_msg( 3, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = rcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "rcv_msg bad ercd !E_NOEXS" );
ercd = trcv_msg( &msg, 3, 10 );
CYG_TEST_CHECK( E_NOEXS == ercd, "trcv_msg bad ercd !E_NOEXS" );
ercd = prcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "prcv_msg bad ercd !E_NOEXS" );
ercd = ref_mbx( &t_rmbx, 3 );
CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mbx bad ercd !E_NOEXS" );
#ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
// now try creating it (badly)
#ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
ercd = cre_mbx( 3, NULL );
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );
#endif
ercd = cre_mbx( 3, NADR );
CYG_TEST_CHECK( E_PAR == ercd, "cre_mbx bad ercd !E_PAR" );
t_cmbx.mbxatr = 0xfff;
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_RSATR == ercd, "cre_mbx bad ercd !E_RSATR" );
t_cmbx.mbxatr = 0;
#endif // we can test bad param error returns
ercd = cre_mbx( 3, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
// and check we can use it
ercd = snd_msg( 3, t_msg );
CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" );
ercd = rcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" );
ercd = trcv_msg( &msg, 3, 2 );
CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" );
ercd = prcv_msg( &msg, 3 );
CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" );
ercd = ref_mbx( &t_rmbx, 3 );
CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" );
// now wait while task 2 deletes the wait objects
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = rcv_msg( &msg, 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = trcv_msg( &msg, 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );
// check they are deleted
ercd = snd_msg( 1, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = snd_msg( 2, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
// re-create and do it again
ercd = cre_mbx( 1, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
ercd = cre_mbx( 2, &t_cmbx );
CYG_TEST_CHECK( E_OK == ercd, "cre_mbx bad ercd" );
// now wait while task 2 deletes the wait objects again
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = rcv_msg( &msg, 1 );
CYG_TEST_CHECK( E_DLT == ercd, "wai_mbx bad ercd !E_DLT" );
ercd = wup_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
ercd = trcv_msg( &msg, 2, 20 );
CYG_TEST_CHECK( E_DLT == ercd, "twai_mbx bad ercd !E_DLT" );
// check they are deleted
ercd = snd_msg( 1, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
ercd = snd_msg( 2, t_msg );
CYG_TEST_CHECK( E_NOEXS == ercd, "snd_msg bad ercd !E_NOEXS" );
CYG_TEST_PASS("create/delete mboxes");
#endif // CYGPKG_UITRON_MBOXES_CREATE_DELETE
ercd = ter_tsk( 2 );
CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );
ercd = dly_tsk( 5 );
CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
// all done
if ( 0 == tests ) {
CYG_TEST_NA( "No objects have create/delete enabled" );
}
else {
CYG_TEST_EXIT( "All done" );
}
ext_tsk();
}
void ITRON_Init( void )
{
ER status;
T_CSEM pk_csem;
T_RSEM pk_rsem;
printf( "\n\n*** ITRONSEM01 -- ITRON SEMAPHORE TEST ***\n" );
/*
* Exercise cre_sem - this code seems to exercise every path.
*/
puts( "Init - cre_sem - NULL pk_sem returns E_PAR" );
status = cre_sem( 1, NULL );
assert( status == E_PAR );
puts( "Init - cre_sem - isemcnt > maxsem returns E_PAR" );
pk_csem.sematr = 0;
pk_csem.isemcnt = 3;
pk_csem.maxsem = 2;
status = cre_sem( 1, &pk_csem );
assert( status == E_PAR );
puts( "Init - cre_sem - maxsem of 0 returns E_PAR" );
pk_csem.isemcnt = 0;
pk_csem.maxsem = 0;
status = cre_sem( 1, &pk_csem );
assert( status == E_PAR );
/*
* Now run through all the bad ID errors
*/
pk_csem.isemcnt = 2;
pk_csem.maxsem = 3;
puts( "Init - cre_sem - bad id (less than -4) - E_OACV" );
status = cre_sem( -5, &pk_csem );
assert( status == E_OACV );
puts( "Init - cre_sem - bad id (between 0 and -4) - E_ID" );
status = cre_sem( -4, &pk_csem );
assert( status == E_ID );
puts( "Init - cre_sem - bad id (0) - E_ID" );
status = cre_sem( 0, &pk_csem );
assert( status == E_ID );
puts( "Init - cre_sem - bad id (too great) - E_ID" );
status = cre_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1, &pk_csem );
assert( status == E_ID );
puts( "Init - cre_sem - create semaphore 1 TA_TFIFO - E_OK" );
pk_csem.isemcnt = 2;
pk_csem.maxsem = 3;
pk_csem.sematr = TA_TFIFO;
status = cre_sem( 1, &pk_csem );
assert( status == E_OK );
puts( "Init - cre_sem - create semaphore 1 again - E_OBJ" );
status = cre_sem( 1, &pk_csem );
assert( status == E_OBJ );
puts( "Init - cre_sem - create semaphore 2 TA_TPRI - E_OK" );
pk_csem.isemcnt = 2;
pk_csem.maxsem = 3;
pk_csem.sematr = TA_TPRI;
status = cre_sem( 2, &pk_csem );
assert( status == E_OK );
/*
* Generate all the bad id errors for del_sem
*/
puts( "Init - del_sem - bad id (less than -4) - E_OACV" );
status = del_sem( -5 );
assert( status == E_OACV );
puts( "Init - del_sem - bad id (between 0 and -4) - E_ID" );
status = del_sem( -4 );
assert( status == E_ID );
puts( "Init - del_sem - bad id (0) - E_ID" );
status = del_sem( 0 );
assert( status == E_ID );
puts( "Init - del_sem - bad id (too great) - E_ID" );
status = del_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for sig_sem
*/
puts( "Init - sig_sem - bad id (less than -4) - E_OACV" );
status = sig_sem( -5 );
assert( status == E_OACV );
puts( "Init - sig_sem - bad id (between 0 and -4) - E_ID" );
status = sig_sem( -4 );
assert( status == E_ID );
puts( "Init - sig_sem - bad id (0) - E_ID" );
status = sig_sem( 0 );
assert( status == E_ID );
puts( "Init - sig_sem - bad id (too great) - E_ID" );
status = wai_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for preq_sem
*/
puts( "Init - preq_sem - bad id (less than -4) - E_OACV" );
status = preq_sem( -5 );
assert( status == E_OACV );
puts( "Init - preq_sem - bad id (between 0 and -4) - E_ID" );
status = preq_sem( -4 );
assert( status == E_ID );
puts( "Init - preq_sem - bad id (0) - E_ID" );
status = preq_sem( 0 );
assert( status == E_ID );
puts( "Init - preq_sem - bad id (too great) - E_ID" );
status = preq_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for wai_sem
*/
puts( "Init - wai_sem - bad id (less than -4) - E_OACV" );
status = wai_sem( -5 );
assert( status == E_OACV );
puts( "Init - wai_sem - bad id (between 0 and -4) - E_ID" );
status = wai_sem( -4 );
assert( status == E_ID );
puts( "Init - wai_sem - bad id (0) - E_ID" );
status = wai_sem( 0 );
assert( status == E_ID );
puts( "Init - wai_sem - bad id (too great) - E_ID" );
status = wai_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1 );
assert( status == E_ID );
/*
* Generate all the bad id errors for twai_sem
*/
puts( "Init - twai_sem - bad id (less than -4) - E_OACV" );
status = twai_sem( -5, 1000 );
assert( status == E_OACV );
puts( "Init - twai_sem - bad id (between 0 and -4) - E_ID" );
status = twai_sem( -4, 1000 );
assert( status == E_ID );
puts( "Init - twai_sem - bad id (0) - E_ID" );
status = twai_sem( 0, 1000 );
assert( status == E_ID );
puts( "Init - twai_sem - bad id (too great) - E_ID" );
status = twai_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1, 1000 );
assert( status == E_ID );
/*
* Generate all the bad id errors for ref_sem
*/
puts( "Init - ref_sem - bad id (less than -4) - E_OACV" );
status = ref_sem( -5, &pk_rsem );
assert( status == E_OACV );
puts( "Init - ref_sem - bad id (between 0 and -4) - E_ID" );
status = ref_sem( -4, &pk_rsem );
assert( status == E_ID );
puts( "Init - ref_sem - bad id (0) - E_ID" );
status = ref_sem( 0, &pk_rsem );
assert( status == E_ID );
puts( "Init - ref_sem - bad id (too great) - E_ID" );
status = ref_sem( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES + 1, &pk_rsem );
assert( status == E_ID );
/*
* Exercise preq_sem (and sig_sem a little)
*/
puts( "Init - preq_sem - semaphore 1 available (count --> 1) - E_OK" );
status = preq_sem( 1 );
assert( status == E_OK );
puts( "Init - preq_sem - semaphore 1 available (count --> 0) - E_OK" );
status = preq_sem( 1 );
assert( status == E_OK );
puts( "Init - preq_sem - semaphore 1 unavailable - E_TMOUT" );
status = preq_sem( 1 );
assert( status == E_TMOUT );
puts( "Init - sig_sem - semaphore 1 (count --> 1) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts("Init - twai_sem(TMO_POL) - semaphore 1 available (count --> 0) - E_OK");
status = twai_sem( 1, TMO_POL );
assert( status == E_OK );
puts( "Init - twai_sem(TMO_POL) - semaphore 1 available - E_TMOUT" );
status = twai_sem( 1, TMO_POL );
assert( status == E_TMOUT );
/*
* Exercise twai_sem
*/
puts( "Init - twai_sem - semaphore 1 unavailable - 1 second E_TMOUT" );
put_time( "Init - starting to block at ");
status = twai_sem( 1, 1000 );
assert( status == E_TMOUT );
put_time( "Init - timed out at ");
puts( "Init - twai_sem - semaphore 1 unavailable - timeout completed" );
/*
* Now let's test exceed the maximum count of semaphore 1
*/
puts( "Init - sig_sem - semaphore 1 (count --> 1) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts( "Init - sig_sem - semaphore 1 (count --> 2) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts( "Init - sig_sem - semaphore 1 (count --> 3) - E_OK" );
status = sig_sem( 1 );
assert( status == E_OK );
puts( "Init - sig_sem - semaphore 1 (count > maximum) - E_QOVR" );
status = sig_sem( 1 );
assert( status == E_QOVR );
/*
* Exercise ref_sem
*/
puts( "Init - ref_sem - NULL pk_sem returns E_PAR" );
status = ref_sem( 1, NULL );
assert( status == E_PAR );
puts( "Init - ref_sem - semaphore 1 - E_OK" );
status = ref_sem( 1, &pk_rsem );
assert( status == E_OK );
printf( "Init - semaphore 1 count = %d\n", pk_rsem.semcnt );
printf( "Init - semaphore 1 waiting tasks = %d\n", pk_rsem.wtsk );
puts( "Init - preq_sem - semaphore 1 (count --> 2) - E_OK" );
status = preq_sem( 1 );
assert( status == E_OK );
puts( "Init - ref_sem - semaphore 1 - E_OK" );
status = ref_sem( 1, &pk_rsem );
assert( status == E_OK );
printf( "Init - semaphore 1 count = %d\n", pk_rsem.semcnt );
printf( "Init - semaphore 1 waiting tasks = %d\n", pk_rsem.wtsk );
/*
* Exercise del_sem
*/
/* XXX really want another task blocking on the semaphore XXX */
puts( "Init - del_sem - semaphore 1 deleted - E_OK" );
status = del_sem( 1 );
assert( status == E_OK );
puts( "Init - XXX need other tasks to complete the test XXX" );
puts( "Init - dly_tsk - 1 second to let other task run" );
status = dly_tsk( 1000 );
assert( status == E_OK );
printf( "*** END OF ITRONSEM01 -- ITRON SEMAPHORE TEST ***\n" );
rtems_test_exit( 0 );
}
