int read_command_line(int n, char *buffer, int buffer_size) {
do {
// Print the command prompt including the command line counter.
printf("SHELL %d> ", n);
fflush(NULL);
// Read input from the user.
if ( fgets(buffer, buffer_size, stdin) == NULL) {
perror("====== ERROR ====> READING COMMAND LINE FAILED :(");
exit(EXIT_FAILURE);
}
// Exit if the user types "exit" and presses enter.
if (strcmp(buffer, "exit\n") == 0) {
printf("Goodbye!\n");
exit(EXIT_FAILURE);
}
// If the user presses enter without typing anything but white
// space, don't update the command line counter, just start over
// again.
} while (empty_line(buffer));
return n+1;
}
void print_subsys(char* file)
{
char line[256];
FILE* fp = 0;
parse_name(file);
fp = fopen(file , "r");
if ( fp != NULL)
{
while (fgets(line, sizeof(line), fp) != NULL)
{
if (empty_line(line) == 0)
{
printf(" ");
fputs(line,stdout);
}
}
fclose(fp);
}
else
{
printf("Error opening '%s'\n",file);
}
}
void *POSIX_Init(
void *argument
)
{
int status;
puts( "\n\n*** POSIX KEY 01 TEST ***" );
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
Allocate_majority_of_workspace(84);
puts("Init: pthread_key_create - ENOMEM (Workspace not available)");
empty_line();
status = pthread_key_create( &Key_id[0], Key_destructor );
fatal_directive_check_status_only( status, ENOMEM, "no workspace available" );
puts( "*** END OF POSIX KEY 01 TEST ***" );
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
/* Converts ASCII hex dump to binary data. Returns the capture length.
If any error is encountered, -1 is returned. */
static int
parse_cosine_hex_dump(FILE_T fh, int pkt_len, guint8* buf, int *err,
gchar **err_info)
{
gchar line[COSINE_LINE_LENGTH];
int i, hex_lines, n, caplen = 0;
/* Calculate the number of hex dump lines, each
* containing 16 bytes of data */
hex_lines = pkt_len / 16 + ((pkt_len % 16) ? 1 : 0);
for (i = 0; i < hex_lines; i++) {
if (file_gets(line, COSINE_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return -1;
}
if (empty_line(line)) {
break;
}
if ((n = parse_single_hex_dump_line(line, buf, i*16)) == -1) {
*err = WTAP_ERR_BAD_RECORD;
*err_info = g_strdup("cosine: hex dump line doesn't have 16 numbers");
return -1;
}
caplen += n;
}
return caplen;
}
int next_srt(FILE *f, int expected, struct SubtitleLine *r)
{
int t_h, t_m, t_s, t_ms;
fscanf(f, " %*d "); // we ignore it
fscanf(f, " %d : %d : %d , %d --> ", &t_h, &t_m, &t_s, &t_ms);
r->begin = timeCreate(t_h*3600 + t_m*60 + t_s, t_ms*1000000);
// TODO and if there are 4 digits ?
fscanf(f, " %d : %d : %d , %d ", &t_h, &t_m, &t_s, &t_ms);
r->end = timeCreate(t_h*3600 + t_m*60 + t_s, t_ms*1000000);
*(r->text) = '\0';
char line[1024];
while(1)
{
if(fgets(line, 1024, f) == NULL || empty_line(line))
break;
strcat(r->text, line);
if(feof(f))
{
strcat(r->text, "\n");
break;
}
}
r->id = expected;
return r->id;
}
int bad_n_c(char *s)
{
char *tmp;
char *tmp2;
if (nb_char(s, '"') == 1 || empty_line(s))
return (0);
while (ft_isspace(*s))
s++;
tmp = ft_strsub(s, 0, 5);
tmp2 = ft_strsub(s, 0, 8);
if (tmp == NULL || tmp2 == NULL || (ft_strcmp(tmp, ".name")
&& ft_strcmp(tmp2, ".comment")))
return (1);
return (0);
}
void *Task_1_through_3(
void *argument
)
{
int status;
puts( "Task_1: sched_yield to Init" );
status = sched_yield();
rtems_test_assert( !status );
/* switch to Task_1 */
/* now do some real testing */
empty_line();
/* get id of this thread */
Task_id = pthread_self();
printf( "Task_1: ID is 0x%08" PRIxpthread_t "\n", Task_id );
/* exercise pthread_equal */
status = pthread_equal( Task_id, Task_id );
if ( status )
puts( "Task_1: pthread_equal - match case passed" );
rtems_test_assert( status );
status = pthread_equal( Init_id, Task_id );
if ( !status )
puts( "Task_1: pthread_equal - different case passed" );
rtems_test_assert( !status );
puts( "Task_1: pthread_equal - first id bad" );
status = pthread_equal( (pthread_t) -1, Task_id );
rtems_test_assert( !status );
puts( "Task_1: pthread_equal - second id bad" );
status = pthread_equal( Init_id, (pthread_t) -1 );
rtems_test_assert( !status );
TEST_END();
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
int
main (int argc, char *argv[])
{
gtk_init (NULL, NULL);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
simple_grid ();
text_grid ();
box_comparison ();
empty_line ();
scrolling ();
insert ();
empty_grid ();
gtk_main ();
return 0;
}
/* Converts ASCII hex dump to binary data. Returns TRUE on success,
FALSE if any error is encountered. */
static gboolean
parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr, int pkt_len,
Buffer* buf, int *err, gchar **err_info)
{
guint8 *pd;
gchar line[COSINE_LINE_LENGTH];
int i, hex_lines, n, caplen = 0;
/* Make sure we have enough room for the packet */
buffer_assure_space(buf, COSINE_MAX_PACKET_LEN);
pd = buffer_start_ptr(buf);
/* Calculate the number of hex dump lines, each
* containing 16 bytes of data */
hex_lines = pkt_len / 16 + ((pkt_len % 16) ? 1 : 0);
for (i = 0; i < hex_lines; i++) {
if (file_gets(line, COSINE_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
if (empty_line(line)) {
break;
}
if ((n = parse_single_hex_dump_line(line, pd, i*16)) == -1) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: hex dump line doesn't have 16 numbers");
return FALSE;
}
caplen += n;
}
phdr->caplen = caplen;
return TRUE;
}
void *POSIX_Init(
void *argument
)
{
int status;
struct timespec timeout;
struct sigaction act;
sigset_t mask;
sigset_t waitset;
int signo;
siginfo_t siginfo;
puts( "\n\n*** POSIX TEST 3 ***" );
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* install a signal handler */
status = sigemptyset( &act.sa_mask );
rtems_test_assert( !status );
act.sa_handler = Signal_handler;
act.sa_flags = 0;
sigaction( SIGUSR1, &act, NULL );
/* initialize signal handler variables */
Signal_count = 0;
Signal_occurred = 0;
/*
* wait on SIGUSR1 for 3 seconds, will timeout
*/
/* initialize the signal set we will wait for to SIGUSR1 */
status = sigemptyset( &waitset );
rtems_test_assert( !status );
status = sigaddset( &waitset, SIGUSR1 );
rtems_test_assert( !status );
timeout.tv_sec = 3;
timeout.tv_nsec = 0;
puts( "Init: waiting on any signal for 3 seconds." );
signo = sigtimedwait( &waitset, &siginfo, &timeout );
rtems_test_assert( signo == -1 );
if ( errno == EAGAIN )
puts( "Init: correctly timed out waiting for SIGUSR1." );
else
printf( "sigtimedwait returned wrong errno - %d\n", errno );
Signal_occurred = 0;
/*
* wait on SIGUSR1 for 3 seconds, will timeout because Task_1 sends SIGUSR2
*/
empty_line();
/* initialize a mask to block SIGUSR2 */
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR2 );
rtems_test_assert( !status );
printf( "Init: Block SIGUSR2\n" );
status = sigprocmask( SIG_BLOCK, &mask, NULL );
rtems_test_assert( !status );
/* create a thread */
status = pthread_create( &Task_id, NULL, Task_1, NULL );
rtems_test_assert( !status );
/* signal handler is still installed, waitset is still set for SIGUSR1 */
timeout.tv_sec = 3;
timeout.tv_nsec = 0;
puts( "Init: waiting on any signal for 3 seconds." );
signo = sigtimedwait( &waitset, &siginfo, &timeout );
/* switch to Task 1 */
if ( errno == EAGAIN )
puts( "Init: correctly timed out waiting for SIGUSR1." );
else
printf( "sigtimedwait returned wrong errno - %d\n", errno );
rtems_test_assert( signo == -1 );
/*
* wait on SIGUSR1 for 3 seconds, Task_2 will send it to us
*/
empty_line();
/* create a thread */
status = pthread_create( &Task_id, NULL, Task_2, NULL );
rtems_test_assert( !status );
/* signal handler is still installed, waitset is still set for SIGUSR1 */
/* wait on SIGUSR1 for 3 seconds, will receive SIGUSR1 from Task_2 */
timeout.tv_sec = 3;
timeout.tv_nsec = 0;
/* just so we can check that these were altered */
siginfo.si_code = -1;
siginfo.si_signo = -1;
siginfo.si_value.sival_int = -1;
puts( "Init: waiting on any signal for 3 seconds." );
signo = sigtimedwait( &waitset, &siginfo, &timeout );
printf( "Init: received (%d) SIGUSR1=%d\n", siginfo.si_signo, SIGUSR1 );
rtems_test_assert( signo == SIGUSR1 );
rtems_test_assert( siginfo.si_signo == SIGUSR1 );
rtems_test_assert( siginfo.si_code == SI_USER );
rtems_test_assert( siginfo.si_value.sival_int != -1 ); /* rtems does always set this */
/* try out a process signal */
empty_line();
puts( "Init: kill with SIGUSR2." );
status = kill( getpid(), SIGUSR2 );
rtems_test_assert( !status );
siginfo.si_code = -1;
siginfo.si_signo = -1;
siginfo.si_value.sival_int = -1;
status = sigemptyset( &waitset );
rtems_test_assert( !status );
status = sigaddset( &waitset, SIGUSR1 );
rtems_test_assert( !status );
status = sigaddset( &waitset, SIGUSR2 );
rtems_test_assert( !status );
puts( "Init: waiting on any signal for 3 seconds." );
signo = sigtimedwait( &waitset, &siginfo, &timeout );
printf( "Init: received (%d) SIGUSR2=%d\n", siginfo.si_signo, SIGUSR2 );
rtems_test_assert( signo == SIGUSR2 );
rtems_test_assert( siginfo.si_signo == SIGUSR2 );
rtems_test_assert( siginfo.si_code == SI_USER );
rtems_test_assert( siginfo.si_value.sival_int != -1 ); /* rtems does always set this */
/* exit this thread */
puts( "*** END OF POSIX TEST 3 ***" );
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
type_noeud_comment *validate_comments(type_noeud_comment *anchor_comment, GtkWidget * entry)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
char *text;
gboolean is_not_the_end;
type_noeud_comment *pt_comment;
int longueur;
type_noeud_comment *pt_prec = NULL, *pt_fin = NULL;
pt_comment = anchor_comment;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
gtk_text_buffer_get_line_count(buffer);
gtk_text_buffer_get_bounds(buffer, &start, &end);
iter = start;
do
{
is_not_the_end = gtk_text_iter_forward_line(&iter);
text = gtk_text_iter_get_text(&start, &iter);
start = iter;
if (pt_comment == NULL)
{
pt_comment = ALLOCATION(type_noeud_comment);
pt_comment->suiv = NULL;
if (anchor_comment == NULL)
{
anchor_comment = pt_comment;
}
else
{
pt_prec->suiv = pt_comment;
}
}
longueur = strlen(text) + 1;
if (longueur > TAILLE_CHAINE)
{
printf("WARNING: la chaine de char: %s a ete tronquee dans validate_comments car sa taille est superieure a %d\n", text, TAILLE_CHAINE);
longueur = TAILLE_CHAINE;
}
/* recopie dans le champs comment en rajoutant un % au debut s'il a ete oublie */
/* on ne fait rien pour les lignes vides */
if (test_comment(text) == 1 || empty_line(text) == 1)
{
memcpy(pt_comment->chaine, text, longueur * sizeof(char));
}
else
{
pt_comment->chaine[0] = '%';
memcpy(&(pt_comment->chaine[1]), text, longueur * sizeof(char));
}
pt_prec = pt_comment;
pt_comment = pt_comment->suiv;
g_free (text);
}
while (is_not_the_end == TRUE);
if (strlen(pt_prec->chaine) > 0 && pt_prec->chaine[strlen(pt_prec->chaine)-1] != '\n')
{
strcat(pt_prec->chaine, "\n");
}
/* Suppression des donnees du buffer */
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_delete(buffer, &start, &end);
/* Suppression du reste de la liste chainee des commentaire ==> utile si on a supprime des commentaires*/
pt_fin = pt_prec;
while (pt_comment != NULL)
{
pt_prec = pt_comment;
pt_comment = pt_comment->suiv;
free(pt_prec);
}
pt_fin->suiv = NULL;
return anchor_comment;
}
rtems_task Init(
rtems_task_argument argument
)
{
struct timespec tv;
struct timespec tr;
int sc;
time_t seconds;
time_t seconds1;
unsigned int remaining;
struct tm tm;
struct timespec delay_request;
puts( "\n\n*** POSIX CLOCK TEST ***" );
tm_build_time( &tm, TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* error cases in clock_gettime and clock_settime */
puts( "Init: clock_gettime - EINVAL (NULL timespec)" );
sc = clock_gettime( CLOCK_REALTIME, NULL );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
puts( "Init: clock_gettime - EINVAL (invalid clockid)" );
sc = clock_gettime( (clockid_t)-1, &tv );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
puts( "Init: clock_settime - EINVAL (invalid clockid)" );
sc = clock_settime( (clockid_t)-1, &tv );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
/* way back near the dawn of time :D */
tv.tv_sec = 1;
tv.tv_nsec = 0;
printf( ctime( &tv.tv_sec ) );
puts( "Init: clock_settime - before 1988 EINVAL" );
sc = clock_settime( CLOCK_REALTIME, &tv );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
/* exercise clock_getres */
puts( "Init: clock_getres - EINVAL (invalid clockid)" );
sc = clock_getres( (clockid_t) -1, &tv );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
puts( "Init: clock_getres - EINVAL (NULL resolution)" );
sc = clock_getres( CLOCK_REALTIME, NULL );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
puts( "Init: clock_getres - SUCCESSFUL" );
sc = clock_getres( CLOCK_REALTIME, &tv );
printf( "Init: resolution = sec (%" PRIdtime_t "), nsec (%ld)\n", tv.tv_sec, tv.tv_nsec );
rtems_test_assert( !sc );
/* set the time of day, and print our buffer in multiple ways */
tv.tv_sec = mktime( &tm );
rtems_test_assert( tv.tv_sec != -1 );
tv.tv_nsec = 0;
/* now set the time of day */
empty_line();
printf( asctime( &tm ) );
puts( "Init: clock_settime - SUCCESSFUL" );
sc = clock_settime( CLOCK_REALTIME, &tv );
rtems_test_assert( !sc );
printf( asctime( &tm ) );
printf( ctime( &tv.tv_sec ) );
/* use sleep to delay */
remaining = sleep( 3 );
rtems_test_assert( !remaining );
/* print new times to make sure it has changed and we can get the realtime */
sc = clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &tv );
rtems_test_assert( !sc );
printf("Time since boot: (%" PRIdtime_t ", %ld)\n", tv.tv_sec,tv.tv_nsec );
sc = clock_gettime( CLOCK_REALTIME, &tv );
rtems_test_assert( !sc );
printf( ctime( &tv.tv_sec ) );
seconds = time( NULL );
printf( ctime( &seconds ) );
/* just to have the value copied out through the parameter */
seconds = time( &seconds1 );
rtems_test_assert( seconds == seconds1 );
/* check the time remaining */
printf( "Init: seconds remaining (%d)\n", (int)remaining );
rtems_test_assert( !remaining );
/* error cases in nanosleep */
empty_line();
puts( "Init: nanosleep - EINVAL (NULL time)" );
sc = nanosleep ( NULL, &tr );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
tv.tv_sec = 0;
tv.tv_nsec = TOD_NANOSECONDS_PER_SECOND * 2;
puts( "Init: nanosleep - EINVAL (too many nanoseconds)" );
sc = nanosleep ( &tv, &tr );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
/* this is an error */
tv.tv_sec = -1;
tv.tv_nsec = 0;
puts( "Init: nanosleep - negative seconds - EINVAL" );
sc = nanosleep ( &tv, &tr );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
/* this is also an error */
tv.tv_sec = 0;
tv.tv_nsec = -1;
puts( "Init: nanosleep - negative nanoseconds - EINVAL" );
sc = nanosleep ( &tv, &tr );
rtems_test_assert( sc == -1 );
rtems_test_assert( errno == EINVAL );
/* this is actually a small delay */
tv.tv_sec = 0;
tv.tv_nsec = 1;
puts( "Init: nanosleep - delay so small results in one tick" );
sc = nanosleep ( &tv, &tr );
rtems_test_assert( !sc );
rtems_test_assert( !tr.tv_sec );
rtems_test_assert( !tr.tv_nsec );
/* use nanosleep to yield */
tv.tv_sec = 0;
tv.tv_nsec = 0;
puts( "Init: nanosleep - yield with remaining" );
sc = nanosleep ( &tv, &tr );
rtems_test_assert( !sc );
rtems_test_assert( !tr.tv_sec );
rtems_test_assert( !tr.tv_nsec );
puts( "Init: nanosleep - yield with NULL time remaining" );
sc = nanosleep ( &tv, NULL );
rtems_test_assert( !sc );
rtems_test_assert( !tr.tv_sec );
rtems_test_assert( !tr.tv_nsec );
/* use nanosleep to delay */
tv.tv_sec = 3;
tv.tv_nsec = 500000;
puts( "Init: nanosleep - 1.05 seconds" );
sc = nanosleep ( &tv, &tr );
rtems_test_assert( !sc );
/* print the current real time again */
sc = clock_gettime( CLOCK_REALTIME, &tv );
rtems_test_assert( !sc );
printf( ctime( &tv.tv_sec ) );
/* check the time remaining */
printf( "Init: sec (%" PRIdtime_t "), nsec (%ld) remaining\n", tr.tv_sec, tr.tv_nsec );
rtems_test_assert( !tr.tv_sec && !tr.tv_nsec );
puts( "Init: nanosleep - 1.35 seconds" );
delay_request.tv_sec = 1;
delay_request.tv_nsec = 35000000;
sc = nanosleep( &delay_request, NULL );
rtems_test_assert( !sc );
/* print the current real time again */
sc = clock_gettime( CLOCK_REALTIME, &tv );
rtems_test_assert( !sc );
printf( ctime( &tv.tv_sec ) );
empty_line();
puts( "clock_gettime - CLOCK_THREAD_CPUTIME_ID -- ENOSYS" );
#if defined(_POSIX_THREAD_CPUTIME)
{
struct timespec tp;
sc = clock_gettime( CLOCK_THREAD_CPUTIME_ID, &tp );
check_enosys( sc );
}
#endif
puts( "clock_settime - CLOCK_PROCESS_CPUTIME_ID -- ENOSYS" );
#if defined(_POSIX_CPUTIME)
{
struct timespec tp;
sc = clock_settime( CLOCK_PROCESS_CPUTIME_ID, &tp );
check_enosys( sc );
}
#endif
puts( "clock_settime - CLOCK_THREAD_CPUTIME_ID -- ENOSYS" );
#if defined(_POSIX_THREAD_CPUTIME)
{
struct timespec tp;
sc = clock_settime( CLOCK_THREAD_CPUTIME_ID, &tp );
check_enosys( sc );
}
#endif
puts( "*** END OF POSIX CLOCK TEST ***" );
rtems_test_exit(0);
}
void *POSIX_Init(
void *argument
)
{
int status;
int scope;
int inheritsched;
int schedpolicy;
size_t stacksize;
#if HAVE_DECL_PTHREAD_ATTR_SETGUARDSIZE
size_t guardsize;
#endif
void *stackaddr;
int detachstate;
struct sched_param schedparam;
pthread_attr_t attr;
pthread_attr_t destroyed_attr;
TEST_BEGIN();
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* exercise init and destroy */
puts( "Init - pthread_attr_init - EINVAL (NULL attr)" );
status = pthread_attr_init( NULL );
fatal_directive_check_status_only( status, EINVAL, "null attribute" );
puts( "Init - pthread_attr_init - SUCCESSFUL" );
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init" );
puts( "Init - initialize and destroy an attribute - SUCCESSFUL" );
status = pthread_attr_init( &destroyed_attr );
posix_service_failed( status, "pthread_attr_init");
status = pthread_attr_destroy( &destroyed_attr );
posix_service_failed( status, "pthread_attr_destroy");
puts( "Init - pthread_attr_destroy - EINVAL (NULL attr)" );
status = pthread_attr_destroy( NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL attribute" );
puts( "Init - pthread_attr_destroy - EINVAL (not initialized)" );
status = pthread_attr_destroy( &destroyed_attr );
fatal_directive_check_status_only( status, EINVAL, "not initialized" );
/* check some errors in pthread_create */
puts( "Init - pthread_create - EINVAL (attr not initialized)" );
status = pthread_create( &Task_id, &destroyed_attr, Task_1, NULL );
fatal_directive_check_status_only( status, EINVAL, "attribute not initialized" );
/* junk stack address */
status = pthread_attr_setstackaddr( &attr, (void *)&schedparam );
posix_service_failed( status, "setstackaddr");
/* must go around pthread_attr_setstacksize to set a bad stack size */
attr.stacksize = 0;
puts( "Init - pthread_create - EINVAL (stacksize too small)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, EINVAL, "stacksize too small" );
/* reset all the fields */
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
#if HAVE_DECL_PTHREAD_ATTR_SETSTACKADDR
attr.stacksize = rtems_configuration_get_work_space_size() * 10;
puts( "Init - pthread_create - EAGAIN (stacksize too large)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, EAGAIN, "stacksize too large" );
#endif
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
/* must go around pthread_attr_set routines to set a bad value */
attr.inheritsched = -1;
puts( "Init - pthread_create - EINVAL (invalid inherit scheduler)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, EINVAL, "invalid inherit scheduler" );
/* check out the error case for system scope not supported */
status = pthread_attr_init( &attr );
posix_service_failed( status, " pthread_attr_init");
/* must go around pthread_attr_set routines to set a bad value */
attr.contentionscope = PTHREAD_SCOPE_SYSTEM;
puts( "Init - pthread_create - ENOTSUP (unsupported system contention scope)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
fatal_directive_check_status_only( status, ENOTSUP,
"unsupported system contention scope" );
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
/* now check out pthread_create for inherit scheduler */
status = pthread_attr_setinheritsched( &attr, PTHREAD_INHERIT_SCHED );
posix_service_failed( status, "pthread_attr_setinheritsched");
puts( "Init - pthread_create - SUCCESSFUL (inherit scheduler)" );
status = pthread_create( &Task_id, &attr, Task_1, NULL );
posix_service_failed( status, "pthread_create");
status = pthread_join( Task_id, NULL );
posix_service_failed( status, " pthread_join");
/* switch to Task_1 */
/* exercise get and set scope */
empty_line();
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init");
puts( "Init - pthread_attr_setscope - EINVAL (NULL attr)" );
status = pthread_attr_setscope( NULL, PTHREAD_SCOPE_PROCESS );
fatal_directive_check_status_only( status, EINVAL , "NULL attr" );
puts( "Init - pthread_attr_setscope - ENOTSUP" );
status = pthread_attr_setscope( &attr, PTHREAD_SCOPE_SYSTEM );
fatal_directive_check_status_only( status, ENOTSUP, "PTHREAD_SCOPE_SYSTEM" );
puts( "Init - pthread_attr_setscope - EINVAL (not initialized attr)" );
status = pthread_attr_setscope( &destroyed_attr, PTHREAD_SCOPE_PROCESS );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setscope - EINVAL (invalid scope)" );
status = pthread_attr_setscope( &attr, -1 );
fatal_directive_check_status_only( status, EINVAL, "invalid scope" );
puts( "Init - pthread_attr_setscope - SUCCESSFUL" );
status = pthread_attr_setscope( &attr, PTHREAD_SCOPE_PROCESS );
posix_service_failed( status, "pthread_attr_setscope");
puts( "Init - pthread_attr_getscope - EINVAL (NULL attr)" );
status = pthread_attr_getscope( NULL, &scope );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getscope - EINVAL (NULL scope)" );
status = pthread_attr_getscope( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL scope" );
puts( "Init - pthread_attr_getscope - EINVAL (not initialized attr)" );
status = pthread_attr_getscope( &destroyed_attr, &scope );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getscope - SUCCESSFUL" );
status = pthread_attr_getscope( &attr, &scope );
posix_service_failed( status, "pthread_attr_getscope");
printf( "Init - current scope attribute = %d\n", scope );
/* exercise get and set inherit scheduler */
empty_line();
puts( "Init - pthread_attr_setinheritsched - EINVAL (NULL attr)" );
status = pthread_attr_setinheritsched( NULL, PTHREAD_INHERIT_SCHED );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setinheritsched - EINVAL (not initialized attr)" );
status =
pthread_attr_setinheritsched( &destroyed_attr, PTHREAD_INHERIT_SCHED );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setinheritsched - ENOTSUP (invalid inheritsched)" );
status = pthread_attr_setinheritsched( &attr, -1 );
fatal_directive_check_status_only( status, ENOTSUP, "invalid inheritsched" );
puts( "Init - pthread_attr_setinheritsched - SUCCESSFUL" );
status = pthread_attr_setinheritsched( &attr, PTHREAD_INHERIT_SCHED );
posix_service_failed( status, "pthread_attr_setinheritsched");
puts( "Init - pthread_attr_getinheritsched - EINVAL (NULL attr)" );
status = pthread_attr_getinheritsched( NULL, &inheritsched );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getinheritsched - EINVAL (NULL inheritsched)" );
status = pthread_attr_getinheritsched( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL inheritsched" );
puts( "Init - pthread_attr_getinheritsched - EINVAL (not initialized attr)" );
status = pthread_attr_getinheritsched( &destroyed_attr, &inheritsched );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getinheritsched - SUCCESSFUL" );
status = pthread_attr_getinheritsched( &attr, &inheritsched );
posix_service_failed( status, "pthread_attr_getinheritsched");
printf( "Init - current inherit scheduler attribute = %d\n", inheritsched );
/* exercise get and set inherit scheduler */
empty_line();
puts( "Init - pthread_attr_setschedpolicy - EINVAL (NULL attr)" );
status = pthread_attr_setschedpolicy( NULL, SCHED_FIFO );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setschedpolicy - EINVAL (not initialized attr)" );
status =
pthread_attr_setschedpolicy( &destroyed_attr, SCHED_OTHER );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setschedpolicy - ENOTSUP (invalid schedpolicy)" );
status = pthread_attr_setschedpolicy( &attr, -1 );
fatal_directive_check_status_only( status, ENOTSUP, "invalid schedpolicy" );
puts( "Init - pthread_attr_setschedpolicy - SUCCESSFUL" );
status = pthread_attr_setschedpolicy( &attr, SCHED_RR );
posix_service_failed( status, "pthread_attr_setschedpolicy");
puts( "Init - pthread_attr_getschedpolicy - EINVAL (NULL attr)" );
status = pthread_attr_getschedpolicy( NULL, &schedpolicy );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getschedpolicy - EINVAL (NULL schedpolicy)" );
status = pthread_attr_getschedpolicy( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedpolicy" );
puts( "Init - pthread_attr_getschedpolicy - EINVAL (not initialized attr)" );
status = pthread_attr_getschedpolicy( &destroyed_attr, &schedpolicy );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getschedpolicy - SUCCESSFUL" );
status = pthread_attr_getschedpolicy( &attr, &schedpolicy );
posix_service_failed( status, "pthread_attr_getschedpolicy");
printf( "Init - current scheduler policy attribute = %d\n", schedpolicy );
/* exercise get and set stack size */
empty_line();
puts( "Init - pthread_attr_setstacksize - EINVAL (NULL attr)" );
status = pthread_attr_setstacksize( NULL, 0 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstacksize - EINVAL (not initialized attr)" );
status =
pthread_attr_setstacksize( &destroyed_attr, 0 );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setstacksize - SUCCESSFUL (low stacksize)" );
status = pthread_attr_setstacksize( &attr, 0 );
posix_service_failed( status, "pthread_attr_setstacksize");
puts( "Init - pthread_attr_setstacksize - SUCCESSFUL (high stacksize)" );
status = pthread_attr_setstacksize( &attr, STACK_MINIMUM_SIZE * 2 );
posix_service_failed( status, "");
puts( "Init - pthread_attr_getstacksize - EINVAL (NULL attr)" );
status = pthread_attr_getstacksize( NULL, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getstacksize - EINVAL (NULL stacksize)" );
status = pthread_attr_getstacksize( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL stacksize" );
puts( "Init - pthread_attr_getstacksize - EINVAL (not initialized attr)" );
status = pthread_attr_getstacksize( &destroyed_attr, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getstacksize - SUCCESSFUL" );
status = pthread_attr_getstacksize( &attr, &stacksize );
posix_service_failed( status, "pthread_attr_getstacksize");
if ( stacksize == (STACK_MINIMUM_SIZE * 2) )
printf( "Init - current stack size attribute is OK\n" );
/* exercise get and set stack address */
empty_line();
puts( "Init - pthread_attr_setstackaddr - EINVAL (NULL attr)" );
status = pthread_attr_setstackaddr( NULL, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstackaddr - EINVAL (not initialized attr)" );
status = pthread_attr_setstackaddr( &destroyed_attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setstackaddr - SUCCESSFUL" );
status = pthread_attr_setstackaddr( &attr, 0 );
posix_service_failed( status, "");
/* get stack addr */
puts( "Init - pthread_attr_getstackaddr - EINVAL (NULL attr)" );
status = pthread_attr_getstackaddr( NULL, &stackaddr );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getstackaddr - EINVAL (NULL stackaddr)" );
status = pthread_attr_getstackaddr( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL stackaddr" );
puts( "Init - pthread_attr_getstackaddr - EINVAL (not initialized attr)" );
status = pthread_attr_getstackaddr( &destroyed_attr, &stackaddr );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getstackaddr - SUCCESSFUL" );
status = pthread_attr_getstackaddr( &attr, &stackaddr );
posix_service_failed( status, "pthread_attr_getstackaddr");
printf( "Init - current stack address attribute = %p\n", stackaddr );
/* exercise get and set stack (as pair) */
empty_line();
#if HAVE_DECL_PTHREAD_ATTR_SETSTACK
puts( "Init - pthread_attr_setstack- EINVAL (NULL attr)" );
status = pthread_attr_setstack( NULL, &stackaddr, 1024 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstack- EINVAL (destroyed attr)" );
status = pthread_attr_setstack( &destroyed_attr, &stackaddr, 1024 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setstack- SUCCESSFUL (< min stack)" );
status = pthread_attr_setstack( &attr, stackaddr, 0 );
posix_service_failed( status, "OK");
puts( "Init - pthread_attr_setstack- SUCCESSFUL (big stack)" );
status = pthread_attr_setstack( &attr, stackaddr, STACK_MINIMUM_SIZE * 2 );
posix_service_failed( status, "OK");
#endif
#if HAVE_DECL_PTHREAD_ATTR_GETSTACK
puts( "Init - pthread_attr_getstack- EINVAL (NULL attr)" );
status = pthread_attr_getstack( NULL, &stackaddr, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getstack- EINVAL (destroyed attr)" );
status = pthread_attr_getstack( &destroyed_attr, &stackaddr, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "&destroyed attr" );
puts( "Init - pthread_attr_getstack- EINVAL (NULL stack)" );
status = pthread_attr_getstack( &attr, NULL, &stacksize );
fatal_directive_check_status_only( status, EINVAL, "&NULL stack" );
puts( "Init - pthread_attr_getstack- EINVAL (NULL stacksize)" );
status = pthread_attr_getstack( &attr, &stackaddr, NULL );
fatal_directive_check_status_only( status, EINVAL, "&NULL size" );
puts( "Init - pthread_attr_getstack- SUCCESSFUL" );
status = pthread_attr_getstack( &attr, &stackaddr, &stacksize );
posix_service_failed( status, "pthread_attr_getstack");
#endif
/* exercise get and set detach state */
empty_line();
#if HAVE_DECL_PTHREAD_ATTR_SETGUARDSIZE
puts( "Init - pthread_attr_setguardsize - EINVAL (NULL attr)" );
status = pthread_attr_setguardsize( NULL, 0 );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setguardsize - EINVAL (not initialized attr)" );
status = pthread_attr_setguardsize( &destroyed_attr, 0 );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setguardsize - SUCCESSFUL (low guardsize)" );
status = pthread_attr_setguardsize( &attr, 0 );
posix_service_failed( status, "pthread_attr_setguardsize");
puts( "Init - pthread_attr_setguardsize - SUCCESSFUL (high guardsize)" );
status = pthread_attr_setguardsize( &attr, STACK_MINIMUM_SIZE * 2 );
posix_service_failed( status, "");
#endif
#if HAVE_DECL_PTHREAD_ATTR_GETGUARDSIZE
puts( "Init - pthread_attr_getguardsize - EINVAL (NULL attr)" );
status = pthread_attr_getguardsize( NULL, &guardsize );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getguardsize - EINVAL (NULL guardsize)" );
status = pthread_attr_getguardsize( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL guardsize" );
puts( "Init - pthread_attr_getguardsize - EINVAL (not initialized attr)" );
status = pthread_attr_getguardsize( &destroyed_attr, &guardsize );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getguardsize - SUCCESSFUL" );
status = pthread_attr_getguardsize( &attr, &guardsize );
posix_service_failed( status, "pthread_attr_getguardsize");
#endif
/* exercise get and set detach state */
empty_line();
puts( "Init - pthread_attr_setdetachstate - EINVAL (NULL attr)" );
status = pthread_attr_setdetachstate( NULL, PTHREAD_CREATE_DETACHED );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setdetachstate - EINVAL (not initialized attr)" );
status =
pthread_attr_setdetachstate( &destroyed_attr, PTHREAD_CREATE_JOINABLE );
fatal_directive_check_status_only( status, EINVAL, "not initialized att" );
puts( "Init - pthread_attr_setdetachstate - EINVAL (invalid detachstate)" );
status = pthread_attr_setdetachstate( &attr, -1 );
fatal_directive_check_status_only( status, EINVAL, "invalid detachstate" );
puts( "Init - pthread_attr_setdetachstate - SUCCESSFUL" );
status = pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
posix_service_failed( status, "pthread_attr_setdetachstate");
puts( "Init - pthread_attr_getdetachstate - EINVAL (NULL attr)" );
status = pthread_attr_getdetachstate( NULL, &detachstate );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_getdetachstate - EINVAL (NULL detatchstate)" );
status = pthread_attr_getdetachstate( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL detatchstate" );
puts( "Init - pthread_attr_getdetachstate - EINVAL (not initialized attr)" );
status = pthread_attr_getdetachstate( &destroyed_attr, &detachstate );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getdetachstate - SUCCESSFUL" );
status = pthread_attr_getdetachstate( &attr, &detachstate );
posix_service_failed( status, "pthread_attr_getdetachstate");
printf( "Init - current detach state attribute = %d\n", detachstate );
/* exercise get and set scheduling parameters */
empty_line();
puts( "Init - pthread_attr_getschedparam - SUCCESSFUL" );
status = pthread_attr_getschedparam( &attr, &schedparam );
posix_service_failed( status, "pthread_attr_getschedparam");
print_schedparam( "Init - ", &schedparam );
puts( "Init - pthread_attr_setschedparam - EINVAL (NULL attr)" );
status = pthread_attr_setschedparam( NULL, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "NULL attr" );
puts( "Init - pthread_attr_setschedparam - EINVAL (not initialized attr)" );
status = pthread_attr_setschedparam( &destroyed_attr, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_setschedparam - EINVAL (NULL schedparam)" );
status = pthread_attr_setschedparam( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
puts( "Init - pthread_attr_setschedparam - SUCCESSFUL" );
status = pthread_attr_setschedparam( &attr, &schedparam );
posix_service_failed( status, "pthread_attr_setschedparam");
puts( "Init - pthread_attr_getschedparam - EINVAL (NULL attr)" );
status = pthread_attr_getschedparam( NULL, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "pthread_attr_getschedparam" );
puts( "Init - pthread_attr_getschedparam - EINVAL (not initialized attr)" );
status = pthread_attr_getschedparam( &destroyed_attr, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "not initialized attr" );
puts( "Init - pthread_attr_getschedparam - EINVAL (NULL schedparam)" );
status = pthread_attr_getschedparam( &attr, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
/* exercise pthread_getschedparam */
empty_line();
puts( "Init - pthread_getschedparam - EINVAL (NULL policy)" );
status = pthread_getschedparam( pthread_self(), NULL, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "NULL policy" );
puts( "Init - pthread_getschedparam - EINVAL (NULL schedparam)" );
status = pthread_getschedparam( pthread_self(), &schedpolicy, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
puts( "Init - pthread_getschedparam - ESRCH (bad thread)" );
status = pthread_getschedparam( (pthread_t) -1, &schedpolicy, &schedparam );
fatal_directive_check_status_only( status, ESRCH, "bad thread" );
puts( "Init - pthread_getschedparam - SUCCESSFUL" );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
posix_service_failed( status, "pthread_getschedparam");
printf( "Init - policy = %d\n", schedpolicy );
print_schedparam( "Init - ", &schedparam );
/* exercise pthread_setschedparam */
empty_line();
puts( "Init - pthread_setschedparam - EINVAL (NULL schedparam)" );
status = pthread_setschedparam( pthread_self(), SCHED_OTHER, NULL );
fatal_directive_check_status_only( status, EINVAL, "NULL schedparam" );
schedparam.sched_priority = -1;
puts( "Init - pthread_setschedparam - EINVAL (invalid priority)" );
status = pthread_setschedparam( pthread_self(), SCHED_OTHER, NULL );
fatal_directive_check_status_only( status, EINVAL, "invalid priority" );
/* reset sched_param */
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
posix_service_failed( status, "pthread_getschedparam");
puts( "Init - pthread_setschedparam - EINVAL (invalid policy)" );
status = pthread_setschedparam( pthread_self(), -1, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "invalid policy" );
puts( "Init - pthread_setschedparam - ESRCH (invalid thread)" );
status = pthread_setschedparam( (pthread_t) -1, SCHED_OTHER, &schedparam );
fatal_directive_check_status_only( status, ESRCH, "invalid thread" );
/* now get sporadic server errors */
schedparam.sched_ss_repl_period.tv_sec = 0;
schedparam.sched_ss_repl_period.tv_nsec = 0;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 1;
puts( "Init - pthread_setschedparam - EINVAL (replenish == 0)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "replenish == 0" );
schedparam.sched_ss_repl_period.tv_sec = 1;
schedparam.sched_ss_repl_period.tv_nsec = 1;
schedparam.sched_ss_init_budget.tv_sec = 0;
schedparam.sched_ss_init_budget.tv_nsec = 0;
puts( "Init - pthread_setschedparam - EINVAL (budget == 0)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "budget == 0" );
schedparam.sched_ss_repl_period.tv_sec = 1;
schedparam.sched_ss_repl_period.tv_nsec = 0;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 1;
puts( "Init - pthread_setschedparam - EINVAL (replenish < budget)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "replenish < budget" );
schedparam.sched_ss_repl_period.tv_sec = 2;
schedparam.sched_ss_repl_period.tv_nsec = 0;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 0;
schedparam.sched_ss_low_priority = -1;
puts( "Init - pthread_setschedparam - EINVAL (invalid priority)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
fatal_directive_check_status_only( status, EINVAL, "invalid priority" );
/*
* Create a sporadic thread that doesn't need it's priority
* boosted
*/
empty_line();
puts( "Init - pthread_attr_init - SUCCESSFUL" );
status = pthread_attr_init( &attr );
posix_service_failed( status, "pthread_attr_init" );
puts( "Init - pthread_attr_setinheritsched - EXPLICIT - SUCCESSFUL" );
status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
rtems_test_assert( !status );
schedparam.sched_ss_repl_period.tv_sec = 3;
schedparam.sched_ss_repl_period.tv_nsec = 3;
schedparam.sched_ss_init_budget.tv_sec = 1;
schedparam.sched_ss_init_budget.tv_nsec = 1;
schedparam.sched_priority = sched_get_priority_max( SCHED_FIFO );
schedparam.sched_ss_low_priority = sched_get_priority_max( SCHED_FIFO ) - 6;
puts( "Init - pthread_attr_setschedpolicy - SUCCESSFUL" );
status = pthread_attr_setschedpolicy( &attr, SCHED_SPORADIC );
posix_service_failed( status, "pthread_attr_setschedparam");
puts( "Init - pthread_attr_setschedparam - SUCCESSFUL" );
status = pthread_attr_setschedparam( &attr, &schedparam );
posix_service_failed( status, "pthread_attr_setschedparam");
status = pthread_create( &Task2_id, &attr, Task_2, NULL );
rtems_test_assert( !status );
status = pthread_join( Task2_id, NULL );
posix_service_failed( status, " pthread_join");
TEST_END();
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
void *POSIX_Init(
void *argument
)
{
int status;
pthread_condattr_t attr;
pthread_condattr_t attr_error;
int pshared;
pthread_cond_t cond;
struct timespec timeout;
puts( "\n\n*** POSIX TEST 10 ***" );
puts( "Init: pthread_condattr_init" );
status = pthread_condattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_condattr_init - EINVAL (attribute invalid)" );
status = pthread_condattr_init( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_condattr_destroy" );
status = pthread_condattr_destroy( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_condattr_destroy - EINVAL (attribute invalid)" );
status = pthread_condattr_destroy( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_condattr_init" );
status = pthread_condattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_condattr_setpshared - PTHREAD_PROCESS_SHARED" );
status = pthread_condattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
rtems_test_assert( !status );
puts( "Init: pthread_condattr_setpshared - PTHREAD_PROCESS_PRIVATE" );
status = pthread_condattr_setpshared( &attr, PTHREAD_PROCESS_PRIVATE );
rtems_test_assert( !status );
status = pthread_condattr_setpshared( NULL, PTHREAD_PROCESS_PRIVATE );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_condattr_setpshared - EINVAL (attribute invalid)" );
status = pthread_condattr_setpshared( &attr, 0x7FFF );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_condattr_setpshared - EINVAL (pshared invalid)" );
status = pthread_condattr_getpshared( &attr, &pshared );
rtems_test_assert( !status );
printf( "Init: pthread_condattr_getpshared - %d\n", pshared );
status = pthread_condattr_getpshared( NULL, &pshared );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_condattr_getpshared - EINVAL (attribute invalid)" );
puts( "Init: pthread_cond_init - NULL attr" );
status = pthread_cond_init( &cond, NULL );
rtems_test_assert( !status );
/* error for attribute not initialized */
attr_error.is_initialized = FALSE;
status = pthread_cond_init( &cond, &attr_error );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_init - EINVAL (attr not initialized)" );
status = pthread_cond_init( &cond, NULL );
if ( status != ENOMEM )
printf( "status = %d\n", status );
rtems_test_assert( status == ENOMEM );
puts( "Init: pthread_cond_init - ENOMEM (too many conds)" );
puts( "Init: pthread_cond_destroy" );
status = pthread_cond_destroy( &cond );
rtems_test_assert( !status );
/* error for bad condition variable passed */
status = pthread_cond_destroy( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_destroy - EINVAL (cond invalid)" );
/* initiailize the attribute for the rest of the test */
puts( "Init: pthread_cond_init - attr" );
status = pthread_cond_init( &Cond1_id, &attr );
rtems_test_assert( !status );
/* signal task1 with a condition variable */
empty_line();
status = pthread_create( &Task_id, NULL, Task_1, NULL );
rtems_test_assert( !status );
/* switch to task1 to allow it to wait for a condition variable */
puts( "Init: sleep to switch to Task_1" );
sleep( 1 );
status = pthread_cond_destroy( &Cond1_id );
if ( status != EBUSY )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
puts( "Init: pthread_cond_destroy - EBUSY (task1 waiting)" );
puts( "Init: pthread_cond_signal" );
status = pthread_cond_signal( &Cond1_id );
rtems_test_assert( !status );
empty_line();
status = pthread_create( &Task2_id, NULL, Task_2, NULL );
rtems_test_assert( !status );
/* switch to task1 and task2 to allow them to wait for broadcast signal */
puts( "Init: sleep - switch to Task_1 and Task_2" );
sleep( 1 );
/* broadcast a condition variable to task1 and task2 */
puts( "Init: pthread_cond_broadcast" );
status = pthread_cond_broadcast( &Cond1_id );
rtems_test_assert( !status );
puts( "Init: sleep - switch to Task_1" );
sleep( 0 );
/* timedwait case - timeout */
status = pthread_mutex_lock( &Mutex_id );
rtems_test_assert( !status );
/* set timeout to 3 seconds */
status = clock_gettime( CLOCK_REALTIME, &timeout );
rtems_test_assert( !status );
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
puts( "Init: pthread_cond_timedwait for 3 seconds" );
status = pthread_cond_timedwait( &Cond1_id, &Mutex_id, &timeout );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
puts( "Init: pthread_cond_timedwait - ETIMEDOUT - (mutex not acquired)" );
status = pthread_mutex_unlock( &Mutex_id );
rtems_test_assert( !status );
/* remaining error messages */
empty_line();
/* errors for bad variable passed */
status = pthread_cond_signal( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_signal - EINVAL (cond invalid)" );
status = pthread_cond_broadcast( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_broadcast - EINVAL (cond invalid)" );
/* acquire mutex so errors will occur */
status = pthread_mutex_lock( &Mutex_id );
rtems_test_assert( !status );
status = pthread_cond_wait( NULL, &Mutex_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_wait - EINVAL (cond invalid)" );
status = pthread_cond_timedwait( NULL, &Mutex_id, &timeout );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_timedwait - EINVAL (cond invalid)" );
status = pthread_cond_wait( &Cond1_id, NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_wait - EINVAL (mutex invalid)" );
status = pthread_cond_timedwait( &Cond1_id, NULL, &timeout );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_timedwait - EINVAL (mutex invalid)" );
status = pthread_cond_timedwait( &Cond1_id, &Mutex_id, NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_cond_timedwait - EINVAL (abstime NULL)" );
status = clock_gettime( CLOCK_REALTIME, &timeout );
rtems_test_assert( !status );
timeout.tv_sec -= 1;
status = pthread_cond_timedwait( &Cond1_id, &Mutex_id, &timeout );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
puts( "Init: pthread_cond_timedwait - ETIMEDOUT (abstime->tv_sec < current time)" );
status = pthread_mutex_unlock( &Mutex_id );
rtems_test_assert( !status );
status = pthread_mutex_lock( &Mutex_id );
rtems_test_assert( !status );
/* ensure we do not catch a 0 nanosecond boundary */
do {
status = clock_gettime( CLOCK_REALTIME, &timeout );
rtems_test_assert( !status );
timeout.tv_nsec -= 1;
} while ( timeout.tv_nsec < 0);
status = pthread_cond_timedwait( &Cond1_id, &Mutex_id, &timeout );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
puts( "Init: pthread_cond_timedwait - ETIMEDOUT (abstime->tv_nsec < current time)" );
status = pthread_mutex_unlock( &Mutex_id );
rtems_test_assert( !status );
/* wait and timedwait without mutex */
/* XXX - this case is commented out in the code pending review
*
* status = pthread_cond_wait( &Cond1_id, &Mutex_id );
* if ( status != EINVAL )
* printf( "status = %d\n", status );
* rtems_test_assert( status == EINVAL );
*/
puts( "Init: pthread_cond_wait - EINVAL (mutex not locked before call)" );
/* XXX - this case is commented out in the code pending review
*
* status = clock_gettime( CLOCK_REALTIME, &timeout );
* rtems_test_assert( !status );
* timeout.tv_sec += 1;
* status = pthread_cond_timedwait( &Cond1_id, &Mutex_id, &timeout );
* if ( status != EINVAL )
* printf( "status = %d\n", status );
* rtems_test_assert( status == EINVAL );
*/
puts( "Init: pthread_cond_timedwait - EINVAL (mutex not locked before call)");
empty_line();
status = pthread_create( &Task3_id, NULL, Task_3, NULL );
rtems_test_assert( !status );
/* switch to task3 to allow it to wait for broadcast signal */
puts( "Init: sleep - switch to Task_3" );
sleep( 1 );
/* destroy the mutex so Task3 can not acguire at the end of Wait_support */
status = pthread_mutex_destroy( &Mutex_id );
rtems_test_assert( !status );
/* signal a condition variable to task3 */
puts( "Init: pthread_cond_signal" );
status = pthread_cond_signal( &Cond1_id );
puts( "Init: sleep - switch to Task_3" );
sleep( 1 );
puts( "*** END OF POSIX TEST 10 ***" );
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
void *POSIX_Init(
void *argument
)
{
int status;
unsigned int remaining;
uint32_t *key_data;
puts( "\n\n*** POSIX TEST 6 ***" );
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08x\n", Init_id );
/* create a couple of threads */
status = pthread_create( &Task_id, NULL, Task_1, NULL );
assert( !status );
status = pthread_create( &Task2_id, NULL, Task_2, NULL );
assert( !status );
/* create a key */
empty_line();
Destructor_invoked = 0;
puts( "Init: pthread_key_create - SUCCESSFUL" );
status = pthread_key_create( &Key_id, Key_destructor );
if ( status )
printf( "status = %d\n", status );
assert( !status );
printf( "Destructor invoked %d times\n", Destructor_invoked );
puts( "Init: pthread_key_create - EAGAIN (too many keys)" );
status = pthread_key_create( &Key_id, Key_destructor );
assert( status == EAGAIN );
puts( "Init: pthread_setspecific - EINVAL (invalid key)" );
status = pthread_setspecific( -1, &Data_array[ 0 ] );
assert( status == EINVAL );
puts( "Init: pthread_getspecific - EINVAL (invalid key)" );
key_data = pthread_getspecific( -1 );
assert( !key_data );
puts( "Init: pthread_key_delete - EINVAL (invalid key)" );
status = pthread_key_delete( -1 );
assert( status == EINVAL );
printf( "Init: Setting the key to %d\n", 0 );
status = pthread_setspecific( Key_id, &Data_array[ 0 ] );
if ( status )
printf( "status = %d\n", status );
assert( !status );
/* switch to task 1 */
key_data = pthread_getspecific( Key_id );
printf( "Init: Got the key value of %ld\n",
(unsigned long) ((uint32_t *)key_data - Data_array) );
remaining = sleep( 3 );
if ( remaining )
printf( "seconds remaining = %d\n", remaining );
assert( !remaining );
/* switch to task 1 */
/* delete the key */
puts( "Init: pthread_key_delete - SUCCESSFUL" );
status = pthread_key_delete( Key_id );
if ( status )
printf( "status = %d\n", status );
assert( !status );
printf( "Destructor invoked %d times\n", Destructor_invoked );
puts( "*** END OF POSIX TEST 6 ***" );
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
void *POSIX_Init(
void *argument
)
{
unsigned int remaining;
int status;
struct sigaction act;
sigset_t mask;
sigset_t pending_set;
sigset_t oset;
struct timespec timeout;
siginfo_t info;
puts( "\n\n*** POSIX TEST 4 ***" );
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* generate some easy error cases */
status = sigwait( NULL, NULL );
if ( status != EINVAL )
printf( "status = %d (%s)\n", status, strerror(status) );
rtems_test_assert( status == EINVAL );
puts( "Init: sigwait - EINVAL (NULL set)" );
status = sigtimedwait( NULL, NULL, NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigwait - EINVAL (NULL set)" );
/* install a signal handler for SIGUSR1 */
status = sigemptyset( &act.sa_mask );
rtems_test_assert( !status );
printf( "Init: sigemptyset - set= 0x%08x\n", (unsigned int) act.sa_mask );
/* test sigfillset following the above sigemptyset */
status = sigfillset( &act.sa_mask );
rtems_test_assert( !status );
printf( "Init: sigfillset - set= 0x%08x\n", (unsigned int) act.sa_mask );
/* test sigdelset */
status = sigdelset( &act.sa_mask, SIGUSR1 );
rtems_test_assert( !status );
printf( "Init: sigdelset - delete SIGUSR1 set= 0x%08x\n",
(unsigned int) act.sa_mask );
/* test sigismember - FALSE */
status = sigismember( &act.sa_mask, SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: sigismember - FALSE since SIGUSR1 is not a member" );
/* test sigismember - TRUE */
status = sigismember( &act.sa_mask, SIGUSR2 );
rtems_test_assert( status );
puts( "Init: sigismember - TRUE since SIGUSR2 is a member" );
/* return the set to empty */
act.sa_handler = Signal_handler;
act.sa_flags = 0;
sigaction( SIGUSR1, &act, NULL );
/* simple signal to process */
Signal_count = 0;
Signal_occurred = 0;
puts( "Init: send SIGUSR1 to process" );
status = kill( getpid(), SIGUSR1 );
rtems_test_assert( !status );
/* end of install a signal handler for SIGUSR1 */
Signal_occurred = 0;
/* now block the signal, send it, see if it is pending, and unblock it */
empty_line();
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR1" );
act.sa_handler = Signal_handler;
act.sa_flags = 0;
sigaction( SIGUSR1, &act, NULL );
/* simple signal to process */
Signal_count = 0;
Signal_occurred = 0;
puts( "Init: send SIGUSR1 to process" );
status = kill( getpid(), SIGUSR1 );
rtems_test_assert( !status );
Signal_occurred = 0;
/* now block the signal, send it, see if it is pending, and unblock it */
empty_line();
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR1" );
status = sigprocmask( SIG_BLOCK, &mask, NULL );
rtems_test_assert( !status );
status = sigpending( &pending_set );
rtems_test_assert( !status );
printf( "Init: Signals pending 0x%08x\n", (unsigned int) pending_set );
puts( "Init: send SIGUSR1 to process" );
status = kill( getpid(), SIGUSR1 );
rtems_test_assert( !status );
status = sigpending( &pending_set );
rtems_test_assert( !status );
printf( "Init: Signals pending 0x%08x\n", (unsigned int) pending_set );
puts( "Init: Unblock SIGUSR1" );
status = sigprocmask( SIG_UNBLOCK, &mask, NULL );
rtems_test_assert( !status );
/* now let another task get interrupted by a signal */
empty_line();
puts( "Init: create a thread interested in SIGUSR1" );
status = pthread_create( &Task1_id, NULL, Task_1, NULL );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR1" );
status = sigprocmask( SIG_BLOCK, &mask, NULL );
rtems_test_assert( !status );
status = sigpending( &pending_set );
rtems_test_assert( !status );
printf( "Init: Signals pending 0x%08x\n", (unsigned int) pending_set );
puts( "Init: sleep so the other task can block" );
remaining = sleep( 1 );
rtems_test_assert( !status );
/* switch to task 1 */
puts( "Init: send SIGUSR1 to process" );
status = kill( getpid(), SIGUSR1 );
rtems_test_assert( !status );
status = sigpending( &pending_set );
rtems_test_assert( !status );
printf( "Init: Signals pending 0x%08x\n", (unsigned int) pending_set );
puts( "Init: sleep so the other task can catch signal" );
remaining = sleep( 1 );
rtems_test_assert( !status );
/* switch to task 1 */
/* test alarm */
empty_line();
/* install a signal handler for SIGALRM and unblock it */
status = sigemptyset( &act.sa_mask );
rtems_test_assert( !status );
act.sa_handler = Signal_handler;
act.sa_flags = 0;
sigaction( SIGALRM, &act, NULL );
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGALRM );
rtems_test_assert( !status );
puts( "Init: Unblock SIGALRM" );
status = sigprocmask( SIG_UNBLOCK, &mask, NULL );
rtems_test_assert( !status );
/* schedule the alarm */
puts( "Init: Firing alarm in 5 seconds" );
remaining = alarm( 5 );
printf( "Init: %d seconds left on previous alarm\n", status );
rtems_test_assert( !status );
puts( "Init: Firing alarm in 2 seconds" );
remaining = alarm( 2 );
printf( "Init: %d seconds left on previous alarm\n", remaining );
rtems_test_assert( remaining == 5 );
puts( "Init: Wait 4 seconds for alarm" );
remaining = sleep( 4 );
printf( "Init: %d seconds left in sleep\n", remaining );
rtems_test_assert( remaining == 2 );
/* test SIG_SETMASK case and returning oset of pthread_sigmask */
empty_line();
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR2 );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR1 and SIGUSR2 only" );
status = pthread_sigmask( SIG_SETMASK, &mask, &oset );
printf( "Init: Previous blocked set was 0x%08x\n", (unsigned int) oset );
rtems_test_assert( !status );
/* test inquiry about current blocked set with pthread_sigmask */
status = pthread_sigmask( 0, NULL, &oset );
printf( "Init: Current blocked set is 0x%08x\n", (unsigned int) oset );
rtems_test_assert( !status );
/* return blocked mask to no signals blocked */
status = sigemptyset( &mask );
rtems_test_assert( !status );
puts( "Init: Unblock all signals" );
status = pthread_sigmask( SIG_SETMASK, &mask, &oset );
printf( "Init: Previous blocked set was 0x%08x\n", (unsigned int) oset );
rtems_test_assert( !status );
/* test sigsuspend */
empty_line();
puts( "Init: create a thread to send Init SIGUSR1" );
status = pthread_create( &Task2_id, NULL, Task_2, NULL );
rtems_test_assert( !status );
status = sigemptyset( &mask );
rtems_test_assert( !status );
puts( "Init: sigsuspend for any signal" );
status = sigsuspend( &mask );
rtems_test_assert( status );
printf( "Init: awakended from sigsuspend status=%08d \n", status );
/* test a SIGINFO case, these are signals sent to a process only */
empty_line();
puts( "Init: create a thread to sent Process SIGUSR1 with SA_SIGINFO" );
status = pthread_create( &Task3_id, NULL, Task_3, NULL );
rtems_test_assert( !status );
/* set action on SIGUSR1 to an info case */
act.sa_handler = Signal_handler;
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = Signal_info_handler;
sigaction( SIGUSR1, &act, NULL );
puts( "Init: sleep so the Task_3 can sigqueue SIGUSR1" );
remaining = sleep( 1 );
rtems_test_assert( !status );
/* switch to task 1 */
puts( "Init: sigqueue occurred" );
/* Send SIGUSR1, Task_3 has issued a sigwaitinfo */
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR1" );
status = sigprocmask( SIG_BLOCK, &mask, NULL );
rtems_test_assert( !status );
puts( "Init: send SIGUSR1 to process" );
status = kill( getpid(), SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: sleep so the Task_3 can receive SIGUSR1" );
remaining = sleep( 1 );
rtems_test_assert( !status );
/* Send SIGUSR1, Task_3 has issued a sigwait */
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR1" );
status = sigprocmask( SIG_BLOCK, &mask, NULL );
rtems_test_assert( !status );
puts( "Init: send SIGUSR1 to process" );
status = kill( getpid(), SIGUSR1 );
rtems_test_assert( !status );
puts( "Init: sleep so the Task_3 can receive SIGUSR1" );
remaining = sleep( 1 );
rtems_test_assert( !status );
/* Send SIGUSR1, Task_3 has issued a sigwaitinfo */
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR2 );
rtems_test_assert( !status );
puts( "Init: Block SIGUSR2" );
status = sigprocmask( SIG_BLOCK, &mask, NULL );
rtems_test_assert( !status );
puts( "Init: send SIGUSR2 to process" );
status = kill( getpid(), SIGUSR2 );
rtems_test_assert( !status );
puts( "Init: sleep so the Task_3 can receive SIGUSR2" );
remaining = sleep( 1 );
rtems_test_assert( !status );
/* Suspend for signal that has already be sent */
status = sigemptyset( &mask );
rtems_test_assert( !status );
puts( "Init: sigsuspend for any signal" );
status = sigsuspend( &mask );
rtems_test_assert( status );
printf( "Init: awakended from sigsuspend status=%d \n", status );
/* generate error cases for psignal */
empty_line();
status = sigemptyset( NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigemptyset - EINVAL (set invalid)" );
status = sigfillset( NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigfillset - EINVAL (set invalid)" );
status = sigaddset( NULL, SIGUSR1 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigaddset - EINVAL (set invalid)" );
status = sigaddset( &mask, 0 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigaddset - EINVAL (signal = 0)" );
status = sigaddset( &mask, 999 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigaddset - EINVAL (set invalid)" );
status = sigdelset( NULL, SIGUSR1 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigdelset - EINVAL (set invalid)" );
status = sigdelset( &mask, 0 );
rtems_test_assert( !status );
puts( "Init: sigdelset - SUCCESSFUL (signal = 0)" );
status = sigdelset( &mask, 999 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigdelset - EINVAL (set invalid)" );
status = sigismember( NULL, SIGUSR1 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigismember - EINVAL (set invalid)" );
status = sigismember( &mask, 0 );
rtems_test_assert( !status );
puts( "Init: sigismember - SUCCESSFUL (signal = 0)" );
status = sigismember( &mask, 999 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigismember - EINVAL (signal invalid)" );
status = sigaction( 0, &act, 0 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigaction - EINVAL (signal = 0)" );
status = sigaction( 999, &act, NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigaction - EINVAL (signal invalid)" );
status = sigaction( SIGKILL, &act, NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigaction - EINVAL (SIGKILL)" );
status = pthread_sigmask( SIG_BLOCK, NULL, NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: pthread_sigmask - EINVAL (set and oset invalid)" );
status = pthread_sigmask( 999, &pending_set, NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: pthread_sigmask - EINVAL (how invalid)" );
status = sigpending( NULL );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: sigpending - EINVAL (set invalid)" );
timeout.tv_nsec = -1;
status = sigtimedwait( &mask, &info, &timeout );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: pthread_sigmask - EINVAL (timout->nsec invalid < 0)" );
timeout.tv_nsec = 0x7fffffff;
status = sigtimedwait( &mask, &info, &timeout );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: pthread_sigmask - EINVAL (timout->nsec invalid to large)" );
status = pthread_kill( Init_id, 999 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: pthread_kill - EINVAL (sig invalid)" );
status = pthread_kill( Init_id, 0 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: pthread_kill - EINVAL (signal = 0)" );
act.sa_handler = SIG_IGN;
act.sa_flags = 0;
sigaction( SIGUSR2, &act, NULL );
status = pthread_kill( Init_id, SIGUSR2 );
rtems_test_assert( !status );
puts( "Init: pthread_kill - SUCCESSFUL (signal = SIG_IGN)" );
status = kill( INT_MAX, SIGUSR1 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == ESRCH );
puts( "Init: kill - ESRCH (pid invalid)" );
status = kill( getpid(), 0 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: kill - EINVAL (signal = 0)" );
status = kill( getpid(), 999 );
if ( status != -1 )
printf( "status = %d\n", status );
rtems_test_assert( errno == EINVAL );
puts( "Init: kill - EINVAL (sig invalid)" );
/* exit this thread */
puts( "*** END OF POSIX TEST 4 ***" );
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
/**
* DESCRIPTION:
*
* Prints a promt to the screen. Reads a command line of the following format from the the user:
*
* cmd0 -a00 -b01 ... -z0n | cmd1 | cmd2 | ... | cmdN -an0 ... -znn
*
* For each command, the fork_and_pipe() function is called with the
* appropiate argv and relative position of the command.
*
* NOTE:
*
* You only have to add code at the end of main, see TODO comment.
*/
int main() {
// Allocate a buffer for the command line read from the user.
char line_buffer[COMMAND_LINE_BUFFER_SIZE];
// We parse the command line using the next_command() parser. The
// parser will populate the following array with the result of each call
// to the parse.
char* argv[MAX_ARGV_SIZE];
// Count the number of non empty command lines.
int line_nr = 0;
// Position of each command in a command line.
enum cmd_pos pos; // {single, first, middle, last}
// Pipe read descriptor to the pipe to the "left".
int left_pipe_read_fd = -1;
// Count the number of children forked for each command line.
int children = 0;
while(1) {
do {
// Print the command prompt including the command line counter.
printf(" %d> ", line_nr);
fflush(NULL);
// Read input from the user.
if ( fgets(line_buffer, COMMAND_LINE_BUFFER_SIZE, stdin) == NULL) {
perror("====== ERROR ====> READING COMMAND LINE FAILED :(");
exit(EXIT_FAILURE);
}
// Exit if the user types "exit" and presses enter.
if (strcmp(line_buffer, "exit\n") == 0) {
printf(" Goodbye!\n");
exit(EXIT_SUCCESS);
}
// If the user presses enter without typing anything else, don't
// update the command line counter, just start over again.
} while (empty_line(line_buffer));
// We got some input from the user.
line_nr++;
// Parse the command line
do {
pos = next_command(line_buffer, argv);
// After the call to the next_command() parser function, the
// command possition within the command line is now available in the pos
// varialble.
DBG("\n%6s command %s\n", pos2str(pos), argv[0]);
// Loop through the argv and print the command data.
int i = 0;
while (argv[i] != NULL) {
DBG(" argv[%d] @ [0x%x] = \"%s\"\n", i, (unsigned int) argv[i], argv[i]);
i++;
}
// Create a pipe fork a new process for the command. We also
// must remember the read descriptor to the new pipe. This
// descriptor will become the read descriptor to the pipe to the
// "left" for the next command (if any).
left_pipe_read_fd = pipe_and_fork(pos, argv, left_pipe_read_fd);
children++;
// When are we done?
} while (pos != single && pos != last);
DBG("\nAfter calling next_command(), line [0x%X] ==>%s<==\n",
(unsigned int) &line_buffer, line_buffer);
// The parent goes here after after all children have been
// created for the command.
// TODO: Make sure shell doesn't print a new prompt until
// all the command processes (children) have terminated.
while(children>0){
wait(NULL);
children--;
}
} // end while(1)
} // end of main()
void *Task_3(
void *argument
)
{
unsigned int remaining;
int status;
int sig;
volatile union sigval value;
sigset_t mask;
siginfo_t info;
value.sival_int = SIGUSR1;
printf( "Task_3: sigqueue SIGUSR1 with value= %d\n", value.sival_int );
status = sigqueue( getpid(), SIGUSR1, value );
rtems_test_assert( !status );
/* catch signal with sigwaitinfo */
empty_line();
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
printf( "Task_3: sigwaitinfo SIGUSR1 with value= %d\n", value.sival_int );
status = sigwaitinfo( &mask, &info );
/* switch to Init */
rtems_test_assert( !(status==-1) );
printf(
"Task_3: si_signo= %d si_code= %d value= %d\n",
info.si_signo,
info.si_code,
info.si_value.sival_int
);
/* catch signal with sigwait */
empty_line();
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
printf( "Task_3: sigwait SIGUSR1\n" );
status = sigwait( &mask, &sig );
/* switch to Init */
rtems_test_assert( !status );
printf( "Task_3: signo= %d\n", sig );
/* catch signal with pause */
empty_line();
status = sigemptyset( &mask );
rtems_test_assert( !status );
status = sigaddset( &mask, SIGUSR1 );
rtems_test_assert( !status );
printf( "Task_3: pause\n" );
status = pause( );
/* switch to Init */
rtems_test_assert( !(status==-1) );
printf( "Task_3: pause= %d\n", status );
/* send signal to Init task before it has pended for a signal */
empty_line();
printf( "Task_3: sending SIGUSR2\n" );
status = pthread_kill( Init_id, SIGUSR2 );
rtems_test_assert( !status );
printf( "Task_3: sleep so the Init task can reguest a signal\n" );
remaining = sleep( 1 );
rtems_test_assert( !status );
rtems_test_assert( remaining == 0 );
/* end of task 3 */
printf( "Task_3: exit\n" );
pthread_exit( NULL );
/* switch to Init */
return NULL; /* just so the compiler thinks we returned something */
}
void *POSIX_Init(
void *argument
)
{
int status;
pthread_mutexattr_t attr;
pthread_mutexattr_t destroyed_attr;
struct timespec times;
struct sched_param param;
int pshared;
int policy;
int protocol;
int ceiling;
int old_ceiling;
int priority;
rtems_test_assert( MUTEX_BAD_ID != PTHREAD_MUTEX_INITIALIZER );
Mutex_bad_id = MUTEX_BAD_ID;
TEST_BEGIN();
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* test pthread_mutex_attr_init */
puts( "Init: pthread_mutexattr_init - EINVAL (NULL attr)" );
status = pthread_mutexattr_init( NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
Print_mutexattr( "Init: ", &attr );
/* create an "uninitialized" attribute structure */
status = pthread_mutexattr_init( &destroyed_attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
status = pthread_mutexattr_destroy( &destroyed_attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutexattr_destroy - EINVAL (NULL attr)" );
status = pthread_mutexattr_destroy( NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_destroy - EINVAL (not initialized)" );
status = pthread_mutexattr_destroy( &destroyed_attr );
rtems_test_assert( status == EINVAL );
/* error cases for set and get pshared attribute */
empty_line();
puts( "Init: pthread_mutexattr_getpshared - EINVAL (NULL attr)" );
status = pthread_mutexattr_getpshared( NULL, &pshared );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getpshared - EINVAL (NULL pshared)" );
status = pthread_mutexattr_getpshared( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getpshared - EINVAL (not initialized)" );
status = pthread_mutexattr_getpshared( &destroyed_attr, &pshared );
rtems_test_assert( status == EINVAL );
pshared = PTHREAD_PROCESS_PRIVATE;
puts( "Init: pthread_mutexattr_setpshared - EINVAL (NULL attr)" );
status = pthread_mutexattr_setpshared( NULL, pshared );
rtems_test_assert( status == EINVAL );
pshared = PTHREAD_PROCESS_PRIVATE;
puts( "Init: pthread_mutexattr_setpshared - EINVAL (not initialized)" );
status = pthread_mutexattr_setpshared( &destroyed_attr, pshared );
rtems_test_assert( status == EINVAL );
/* error cases for set and get protocol attribute */
empty_line();
puts( "Init: pthread_mutexattr_getprotocol - EINVAL (NULL attr)" );
status = pthread_mutexattr_getprotocol( NULL, &protocol );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprotocol - EINVAL (NULL protocol)" );
status = pthread_mutexattr_getprotocol( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprotocol - EINVAL (not initialized)" );
status = pthread_mutexattr_getprotocol( &destroyed_attr, &protocol );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprotocol - EINVAL (NULL attr)" );
status = pthread_mutexattr_setprotocol( NULL, PTHREAD_PRIO_NONE );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprotocol - EINVAL (invalid protocol)" );
status = pthread_mutexattr_setprotocol( &attr, -1 );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprotocol - EINVAL (not initialized)" );
status = pthread_mutexattr_setprotocol( &destroyed_attr, -1 );
rtems_test_assert( status == EINVAL );
/* error cases for set and get prioceiling attribute */
empty_line();
puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (NULL attr)" );
status = pthread_mutexattr_getprioceiling( NULL, &ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (NULL prioceiling)" );
status = pthread_mutexattr_getprioceiling( &attr, NULL );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_getprioceiling - EINVAL (not initialized)" );
status = pthread_mutexattr_getprioceiling( &destroyed_attr, &ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (NULL attr)" );
status = pthread_mutexattr_setprioceiling( NULL, 128 );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (invalid priority)" );
status = pthread_mutexattr_setprioceiling( &attr, 512 );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutexattr_setprioceiling - EINVAL (not initialized)" );
status = pthread_mutexattr_setprioceiling( &destroyed_attr, -1 );
rtems_test_assert( status == EINVAL );
/* create a thread */
status = pthread_create( &Task_id, NULL, Task_1, NULL );
rtems_test_assert( !status );
/* now try some basic mutex operations */
empty_line();
puts( "Init: pthread_mutex_init - EINVAL (NULL mutex_id)" );
status = pthread_mutex_init( NULL, &attr );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_init - EINVAL (not initialized attr)" );
status = pthread_mutex_init( &Mutex_id, &destroyed_attr );
rtems_test_assert( status == EINVAL );
/* must get around error checks in attribute set routines */
attr.protocol = -1;
puts( "Init: pthread_mutex_init - EINVAL (bad protocol)" );
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* must get around error checks in attribute set routines */
attr.protocol = PTHREAD_PRIO_INHERIT;
attr.prio_ceiling = -1;
puts( "Init: pthread_mutex_init - EINVAL (bad priority ceiling)" );
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* must get around various error checks before checking bad scope */
puts( "Init: Resetting mutex attributes" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - ENOSYS (process wide scope)" );
attr.process_shared = PTHREAD_PROCESS_SHARED;
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == ENOSYS );
puts( "Init: pthread_mutex_init - EINVAL (invalid scope)" );
attr.process_shared = -1;
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* bad kind */
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - EINVAL (invalid type)" );
attr.type = -1;
status = pthread_mutex_init( &Mutex_id, &attr );
rtems_test_assert( status == EINVAL );
/* now set up for a success pthread_mutex_init */
puts( "Init: Resetting mutex attributes" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: Changing mutex attributes" );
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
status = pthread_mutexattr_setprioceiling(
&attr,
(sched_get_priority_max(SCHED_FIFO) / 2) + 1
);
rtems_test_assert( !status );
status = pthread_mutexattr_setpshared( &attr, PTHREAD_PROCESS_SHARED );
rtems_test_assert( !status );
Print_mutexattr( "Init: ", &attr );
puts( "Init: Resetting mutex attributes" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
/*
* Set the protocol to priority ceiling so the owner check happens
* and the EPERM test (later) will work.
*/
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex_id, &attr );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
/*
* This is not required to be an error and when it is, there are
* behavioral conflicts with other implementations.
*/
puts( "Init: pthread_mutex_init - EBUSY (reinitialize an existing mutex) - skipped" );
#if 0
status = pthread_mutex_init( &Mutex_id, &attr );
if ( !status )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
#endif
puts( "Init: pthread_mutex_trylock - EINVAL (illegal ID)" );
status = pthread_mutex_trylock( &Mutex_bad_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_trylock - EDEADLK (already locked)" );
status = pthread_mutex_trylock( &Mutex_id );
if ( status != EBUSY )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
puts( "Init: pthread_mutex_lock - EINVAL (NULL id)" );
status = pthread_mutex_lock( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_unlock - EINVAL (NULL id)" );
status = pthread_mutex_unlock( NULL );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_lock - EDEADLK (already locked)" );
status = pthread_mutex_lock( &Mutex_id );
if ( status != EDEADLK )
printf( "status = %d\n", status );
rtems_test_assert( status == EDEADLK );
puts( "Init: Sleep 1 second" );
sleep( 1 );
/* switch to task 1 */
puts( "Init: pthread_mutex_unlock - EINVAL (invalid id)" );
status = pthread_mutex_unlock( &Mutex_bad_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_unlock - EPERM (not owner)" );
status = pthread_mutex_unlock( &Mutex_id );
if ( status != EPERM )
printf( "status = %d\n", status );
rtems_test_assert( status == EPERM );
puts( "Init: pthread_mutex_timedlock - time out in 1/2 second" );
calculate_abstimeout( ×, 0, (TOD_NANOSECONDS_PER_SECOND / 2) );
status = pthread_mutex_timedlock( &Mutex_id, × );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
puts( "Init: pthread_mutex_timedlock - time out in the past" );
calculate_abstimeout( ×, -1, (TOD_NANOSECONDS_PER_SECOND / 2) );
status = pthread_mutex_timedlock( &Mutex_id, × );
if ( status != ETIMEDOUT )
printf( "status = %d\n", status );
rtems_test_assert( status == ETIMEDOUT );
/* switch to idle */
puts( "Init: pthread_mutex_timedlock - EAGAIN (timeout)" );
/* destroy a mutex */
empty_line();
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - EAGAIN (too many)" );
status = pthread_mutex_init( &Mutex3_id, &attr );
rtems_test_assert( status == EAGAIN );
puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
status = pthread_mutexattr_destroy( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
status = pthread_mutex_destroy( &Mutex2_id );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - EINVAL (invalid id)" );
status = pthread_mutex_destroy( &Mutex_bad_id );
rtems_test_assert( status == EINVAL );
/* destroy a busy mutex */
empty_line();
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex2_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - EBUSY (already locked)" );
status = pthread_mutex_destroy( &Mutex2_id );
if ( status != EBUSY )
printf( "status = %d\n", status );
rtems_test_assert( status == EBUSY );
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex2_id );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
status = pthread_mutex_destroy( &Mutex2_id );
rtems_test_assert( !status );
/* priority inherit mutex */
empty_line();
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts(
"Init: pthread_mutexattr_setprotocol - SUCCESSFUL (PTHREAD_PRIO_INHERIT)"
);
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex2_id );
rtems_test_assert( !status );
/* create a thread at a lower priority */
status = pthread_create( &Task2_id, NULL, Task_2, NULL );
rtems_test_assert( !status );
/* set priority of Task2 to highest priority */
param.sched_priority = sched_get_priority_max( SCHED_FIFO );
puts( "Init: pthread_setschedparam - Setting Task2 priority to highest" );
status = pthread_setschedparam( Task2_id, SCHED_FIFO, ¶m );
rtems_test_assert( !status );
/* switching to Task2 */
status = pthread_getschedparam( pthread_self(), &policy, ¶m );
rtems_test_assert( !status );
printf( "Init: pthread_getschedparam - priority = %d\n", param.sched_priority);
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex2_id );
rtems_test_assert( !status );
puts( "Init: pthread_mutexattr_destroy - SUCCESSFUL" );
status = pthread_mutexattr_destroy( &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_destroy - SUCCESSFUL" );
status = pthread_mutex_destroy( &Mutex2_id );
rtems_test_assert( !status );
/* priority ceiling mutex */
empty_line();
puts( "Init: pthread_mutexattr_init - SUCCESSFUL" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
puts(
"Init: pthread_mutexattr_setprotocol - SUCCESSFUL (PTHREAD_PRIO_PROTECT)"
);
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_PROTECT );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_init - SUCCESSFUL" );
status = pthread_mutex_init( &Mutex2_id, &attr );
rtems_test_assert( !status );
puts( "Init: pthread_mutex_getprioceiling - EINVAL (invalid id)" );
status = pthread_mutex_getprioceiling( &Mutex_bad_id, &ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_getprioceiling - EINVAL (NULL ceiling)" );
status = pthread_mutex_getprioceiling( &Mutex2_id, NULL );
rtems_test_assert( status == EINVAL );
status = pthread_mutex_getprioceiling( &Mutex2_id, &ceiling );
rtems_test_assert( !status );
printf( "Init: pthread_mutex_getprioceiling - %d\n", ceiling );
puts( "Init: pthread_mutex_setprioceiling - EINVAL (invalid id)" );
status = pthread_mutex_setprioceiling( &Mutex_bad_id, 200, &old_ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_setprioceiling - EINVAL (illegal priority)" );
status = pthread_mutex_setprioceiling( &Mutex2_id, 512, &old_ceiling );
rtems_test_assert( status == EINVAL );
puts( "Init: pthread_mutex_setprioceiling - EINVAL (NULL ceiling)" );
status = pthread_mutex_setprioceiling( &Mutex2_id, 128, NULL );
rtems_test_assert( status == EINVAL );
/* normal cases of set priority ceiling */
priority = sched_get_priority_max( SCHED_FIFO );
priority = (priority == 254) ? 200 : 13;
printf( "Init: pthread_mutex_setprioceiling - new ceiling = %d\n", priority );
status = pthread_mutex_setprioceiling( &Mutex2_id, priority, &old_ceiling );
rtems_test_assert( !status );
printf(
"Init: pthread_mutex_setprioceiling - old ceiling = %d\n",old_ceiling
);
status = pthread_getschedparam( pthread_self(), &policy, ¶m );
rtems_test_assert( !status );
printf(
"Init: pthread_getschedparam - priority = %d\n", param.sched_priority
);
puts( "Init: pthread_mutex_trylock - SUCCESSFUL" );
status = pthread_mutex_trylock( &Mutex2_id );
rtems_test_assert( !status );
status = pthread_getschedparam( pthread_self(), &policy, ¶m );
rtems_test_assert( !status );
printf(
"Init: pthread_getschedparam - priority = %d\n", param.sched_priority
);
/* create a thread at a higher priority */
status = pthread_create( &Task3_id, NULL, Task_3, NULL );
rtems_test_assert( !status );
/* set priority of Task3 to highest priority */
param.sched_priority = --priority;
status = pthread_setschedparam( Task3_id, SCHED_FIFO, ¶m );
rtems_test_assert( !status );
puts( "Init: pthread_setschedparam - set Task3 priority to highest" );
/* DOES NOT SWITCH to Task3 */
puts( "Init: Sleep 1 second" );
rtems_test_assert( !status );
sleep( 1 );
/* switch to task 3 */
puts( "Init: pthread_mutex_unlock - SUCCESSFUL" );
status = pthread_mutex_unlock( &Mutex2_id );
rtems_test_assert( !status );
status = pthread_mutex_getprioceiling( &Mutex2_id, &ceiling );
rtems_test_assert( !status );
printf( "Init: pthread_mutex_getprioceiling- ceiling = %d\n", ceiling );
/* set priority of Init to highest priority */
param.sched_priority = sched_get_priority_max(SCHED_FIFO);
status = pthread_setschedparam( Init_id, SCHED_FIFO, ¶m );
rtems_test_assert( !status );
puts( "Init: pthread_setschedparam - set Init priority to highest" );
puts( "Init: pthread_mutex_lock - EINVAL (priority ceiling violation)" );
status = pthread_mutex_lock( &Mutex2_id );
if ( status != EINVAL )
printf( "status = %d\n", status );
rtems_test_assert( status == EINVAL );
/* mutexinit.c: Initialising recursive mutex */
puts( "Init: Recursive Mutex" );
status = pthread_mutex_destroy( &Mutex2_id );
if( status )
printf( "status mutex destroy:%d\n", status );
status = pthread_mutexattr_init( &attr );
if( status )
printf( "status mutexattr:%d\n", status );
attr.recursive=true;
status = pthread_mutex_init( &Mutex2_id, &attr );
if ( status )
printf( "status recursive mutex :%d\n", status );
rtems_test_assert( !status );
TEST_END();
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
void *POSIX_Init(
void *argument
)
{
int status;
int passes;
int schedpolicy;
int priority;
struct sched_param schedparam;
char buffer[ 80 ];
pthread_mutexattr_t attr;
time_t start;
time_t now;
TEST_BEGIN();
/* set the time of day, and print our buffer in multiple ways */
set_time( TM_FRIDAY, TM_MAY, 24, 96, 11, 5, 0 );
/* get id of this thread */
Init_id = pthread_self();
printf( "Init's ID is 0x%08" PRIxpthread_t "\n", Init_id );
/* try to use this thread as a sporadic server */
puts( "Init: pthread_getschedparam - SUCCESSFUL" );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
priority = schedparam.sched_priority;
sprintf( buffer, " - current priority = %d", priority );
print_current_time( "Init: ", buffer );
schedparam.sched_ss_repl_period.tv_sec = 0;
schedparam.sched_ss_repl_period.tv_nsec = 500000000; /* 1/2 second */
schedparam.sched_ss_init_budget.tv_sec = 0;
schedparam.sched_ss_init_budget.tv_nsec = 250000000; /* 1/4 second */
schedparam.sched_priority = sched_get_priority_max(SCHED_SPORADIC);
schedparam.sched_ss_low_priority = sched_get_priority_max(SCHED_SPORADIC) - 2;
puts( "Init: pthread_setschedparam - SUCCESSFUL (sporadic server)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
rtems_test_assert( !status );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
/* go into a loop consuming CPU time to watch our priority change */
for ( passes=0 ; passes <= 3 ; ) {
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
if ( priority != schedparam.sched_priority ) {
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
passes++;
}
}
/* now see if this works if we are holding a priority ceiling mutex */
empty_line();
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
schedparam.sched_ss_repl_period.tv_sec = 0;
schedparam.sched_ss_repl_period.tv_nsec = 500000000; /* 1/2 second */
schedparam.sched_ss_init_budget.tv_sec = 0;
schedparam.sched_ss_init_budget.tv_nsec = 250000000; /* 1/4 second */
HIGH_PRIORITY = sched_get_priority_max( SCHED_SPORADIC );
MEDIUM_PRIORITY = sched_get_priority_max( SCHED_SPORADIC ) - 2;
LOW_PRIORITY = sched_get_priority_max( SCHED_SPORADIC ) - 4;
schedparam.sched_priority = HIGH_PRIORITY;
schedparam.sched_ss_low_priority = LOW_PRIORITY;
puts( "Init: pthread_setschedparam - SUCCESSFUL (sporadic server)" );
status = pthread_setschedparam( pthread_self(), SCHED_SPORADIC, &schedparam );
rtems_test_assert( !status );
puts( "Init: Initializing mutex attributes for priority ceiling" );
status = pthread_mutexattr_init( &attr );
rtems_test_assert( !status );
status = pthread_mutexattr_setprotocol( &attr, PTHREAD_PRIO_INHERIT );
rtems_test_assert( !status );
puts( "Init: Creating a mutex" );
status = pthread_mutex_init( &Mutex_id, &attr );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
/* go into a loop consuming CPU time to watch our priority NOT lower */
start = time( &start );
puts( "Init: pthread_mutex_lock acquire the lock" );
status = pthread_mutex_lock( &Mutex_id );
if ( status )
printf( "status = %d %s\n", status, strerror(status) );
rtems_test_assert( !status );
for ( ; ; ) {
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
if ( schedparam.sched_priority == LOW_PRIORITY ) {
puts( "ERROR - Init's priority lowered while holding mutex" );
rtems_test_exit(0);
}
now = time( &now );
if ( now - start > 3 )
break;
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
break;
}
/* with this unlock we should be able to go to low priority */
puts( "Init: unlock mutex" );
status = pthread_mutex_unlock( &Mutex_id );
if ( status )
printf( "status = %d\n", status );
rtems_test_assert( !status );
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
for ( ; ; ) {
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
if ( schedparam.sched_priority == LOW_PRIORITY )
break;
}
status = pthread_getschedparam( pthread_self(), &schedpolicy, &schedparam );
rtems_test_assert( !status );
priority = schedparam.sched_priority;
sprintf( buffer, " - new priority = %d", priority );
print_current_time( "Init: ", buffer );
TEST_END();
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
void *Task_1_through_3(
void *argument
)
{
int status;
pthread_once_t once = PTHREAD_ONCE_INIT;
puts( "Task_1: sched_yield to Init" );
status = sched_yield();
rtems_test_assert( !status );
/* switch to Task_1 */
/* now do some real testing */
empty_line();
/* get id of this thread */
Task_id = pthread_self();
printf( "Task_1: ID is 0x%08" PRIxpthread_t "\n", Task_id );
/* exercise pthread_equal */
status = pthread_equal( Task_id, Task_id );
if ( status )
puts( "Task_1: pthread_equal - match case passed" );
rtems_test_assert( status );
status = pthread_equal( Init_id, Task_id );
if ( !status )
puts( "Task_1: pthread_equal - different case passed" );
rtems_test_assert( !status );
puts( "Task_1: pthread_equal - first id bad" );
status = pthread_equal( (pthread_t) -1, Task_id );
rtems_test_assert( !status );
puts( "Task_1: pthread_equal - second id bad" );
status = pthread_equal( Init_id, (pthread_t) -1 );
rtems_test_assert( !status );
/* exercise pthread_once */
puts( "Task_1: pthread_once - EINVAL (NULL once_control)" );
status = pthread_once( NULL, Test_init_routine );
rtems_test_assert( status == EINVAL );
puts( "Task_1: pthread_once - EINVAL (NULL init_routine)" );
status = pthread_once( &once, NULL );
rtems_test_assert( status == EINVAL );
puts( "Task_1: pthread_once - SUCCESSFUL (init_routine executes)" );
status = pthread_once( &once, Test_init_routine );
rtems_test_assert( !status );
puts( "Task_1: pthread_once - SUCCESSFUL (init_routine does not execute)" );
status = pthread_once( &once, Test_init_routine );
rtems_test_assert( !status );
puts( "*** END OF POSIX TEST 1 ***" );
rtems_test_exit( 0 );
return NULL; /* just so the compiler thinks we returned something */
}
/* Parses a packet record header. There are two possible formats:
1) output to a control blade with date and time
2002-5-10,20:1:31.4: l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
2) output to PE without date and time
l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] */
static gboolean
parse_cosine_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
char *line, int *err, gchar **err_info)
{
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
int num_items_scanned;
int yy, mm, dd, hr, min, sec, csec, pkt_len;
int pro, off, pri, rm, error;
guint code1, code2;
char if_name[COSINE_MAX_IF_NAME_LEN] = "", direction[6] = "";
struct tm tm;
guint8 *pd;
int i, hex_lines, n, caplen = 0;
if (sscanf(line, "%4d-%2d-%2d,%2d:%2d:%2d.%9d:",
&yy, &mm, &dd, &hr, &min, &sec, &csec) == 7) {
/* appears to be output to a control blade */
num_items_scanned = sscanf(line,
"%4d-%2d-%2d,%2d:%2d:%2d.%9d: %5s (%127[A-Za-z0-9/:]), Length:%9d, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
&yy, &mm, &dd, &hr, &min, &sec, &csec,
direction, if_name, &pkt_len,
&pro, &off, &pri, &rm, &error,
&code1, &code2);
if (num_items_scanned != 17) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: purported control blade line doesn't have code values");
return FALSE;
}
} else {
/* appears to be output to PE */
num_items_scanned = sscanf(line,
"%5s (%127[A-Za-z0-9/:]), Length:%9d, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
direction, if_name, &pkt_len,
&pro, &off, &pri, &rm, &error,
&code1, &code2);
if (num_items_scanned != 10) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: header line is neither control blade nor PE output");
return FALSE;
}
yy = mm = dd = hr = min = sec = csec = 0;
}
if (pkt_len < 0) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: packet header has a negative packet length");
return FALSE;
}
if (pkt_len > WTAP_MAX_PACKET_SIZE) {
/*
* Probably a corrupt capture file; don't blow up trying
* to allocate space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("cosine: File has %u-byte packet, bigger than maximum of %u",
pkt_len, WTAP_MAX_PACKET_SIZE);
return FALSE;
}
phdr->rec_type = REC_TYPE_PACKET;
phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
tm.tm_year = yy - 1900;
tm.tm_mon = mm - 1;
tm.tm_mday = dd;
tm.tm_hour = hr;
tm.tm_min = min;
tm.tm_sec = sec;
tm.tm_isdst = -1;
phdr->ts.secs = mktime(&tm);
phdr->ts.nsecs = csec * 10000000;
phdr->len = pkt_len;
/* XXX need to handle other encapsulations like Cisco HDLC,
Frame Relay and ATM */
if (strncmp(if_name, "TEST:", 5) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_TEST;
} else if (strncmp(if_name, "PPoATM:", 7) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_PPoATM;
} else if (strncmp(if_name, "PPoFR:", 6) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_PPoFR;
} else if (strncmp(if_name, "ATM:", 4) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_ATM;
} else if (strncmp(if_name, "FR:", 3) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_FR;
} else if (strncmp(if_name, "HDLC:", 5) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_HDLC;
} else if (strncmp(if_name, "PPP:", 4) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_PPP;
} else if (strncmp(if_name, "ETH:", 4) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_ETH;
} else {
pseudo_header->cosine.encap = COSINE_ENCAP_UNKNOWN;
}
if (strncmp(direction, "l2-tx", 5) == 0) {
pseudo_header->cosine.direction = COSINE_DIR_TX;
} else if (strncmp(direction, "l2-rx", 5) == 0) {
pseudo_header->cosine.direction = COSINE_DIR_RX;
}
g_strlcpy(pseudo_header->cosine.if_name, if_name,
COSINE_MAX_IF_NAME_LEN);
pseudo_header->cosine.pro = pro;
pseudo_header->cosine.off = off;
pseudo_header->cosine.pri = pri;
pseudo_header->cosine.rm = rm;
pseudo_header->cosine.err = error;
/* Make sure we have enough room for the packet */
ws_buffer_assure_space(buf, pkt_len);
pd = ws_buffer_start_ptr(buf);
/* Calculate the number of hex dump lines, each
* containing 16 bytes of data */
hex_lines = pkt_len / 16 + ((pkt_len % 16) ? 1 : 0);
for (i = 0; i < hex_lines; i++) {
if (file_gets(line, COSINE_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
if (empty_line(line)) {
break;
}
if ((n = parse_single_hex_dump_line(line, pd, i*16)) == -1) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: hex dump line doesn't have 16 numbers");
return FALSE;
}
caplen += n;
}
phdr->caplen = caplen;
return TRUE;
}
int main()
{
if (!strisprefix("", ""))
error("\"\" is not a prefix of \"\"");
if (!strisprefix("a", ""))
error("\"\" is not a prefix of a");
if (!strisprefix("a", "a"))
error("a is not a prefix of a");
if (!strisprefix("aa", "a"))
error("a is not a prefix of aa");
if (strisprefix("a", "b"))
error("b is a prefix of a");
if (strcmp(skip_ws(""), ""))
error("skip_ws of \"\" is not \"\"");
if (strcmp(skip_ws("\na"), "a"))
error("skip_ws of \\na is not a");
if (strcmp(skip_ws("\n\na"), "a"))
error("skip_ws of \\n\\na is not a");
if (strcmp(skip_ws("\n a"), "a"))
error("skip_ws of \\n a is not a");
if (strcmp(skip_ws("\n \ta"), "a"))
error("skip_ws of \\n \\ta is not a");
if (strcmp(skip_ws("\n \t"), ""))
error("skip_ws of \\n \\t is not \"\"");
if (strcmp(skip_ws(" "), ""))
error("skip_ws of \" \" is not \"\"");
if (strcmp(skip_nonws(""), ""))
error("skip_nonws of \"\" is not \"\"");
if (strcmp(skip_nonws("a"), ""))
error("skip_nonws of a is not \"\"");
if (strcmp(skip_nonws("\n"), "\n"))
error("skip_nonws of \\n is not \\n");
if (strcmp(skip_nonws(" "), " "))
error("skip_nonws of \" \" is not \" \"");
if (strcmp(skip_nonws("\t"), "\t"))
error("skip_nonws of \\t is not \\t");
if (strcmp(skip_nonws("a\n"), "\n"))
error("skip_nonws of a\\n is not \\n");
if (strcmp(skip_nonws("ab"), ""))
error("skip_nonws of ab is not \"\"");
if (!empty_line(""))
error("empty_line is false for \"\"");
if (!empty_line("\n\t "))
error("empty_line is false for \"\\n\\n \"");
if (!empty_line(" "))
error("empty_line is false for \" \"");
if (empty_line("\r"))
error("empty_line is true for \\r");
if (comment_line(""))
error("comment_line is true for \"\"");
if (comment_line("\n"))
error("comment_line is true for \n");
if (!comment_line("#"))
error("comment_line is false for #");
if (!comment_line(" #"))
error("comment_line is false for \" #\"");
/* this is what the spec says */
if (!comment_line("\n#"))
error("comment_line is false for \\n#");
if (!comment_line("\t#"))
error("comment_line is false for \\t#");
return EXIT_SUCCESS;
}
