lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-08-01 10:06:57 +03:00
Code Activity

pthread: Move some attr tests from nptl to sysdeps/pthread

Browse Source 
So they can be checked with htl too.
This commit is contained in:
Samuel Thibault
2020-02-09 17:30:30 +00:00
parent 34f168fb82
commit 44a41fc253
3 changed files with 2 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
sysdeps/pthread/Makefile
View File

@ -42,6 +42,7 @@ libpthread-routines += thrd_create thrd_detach thrd_exit thrd_join \
tests += tst-cnd-basic tst-mtx-trylock tst-cnd-broadcast \
tst-cnd-timedwait tst-thrd-detach tst-mtx-basic tst-thrd-sleep \
tst-mtx-recursive tst-tss-basic tst-call-once tst-mtx-timedlock \
tst-attr1 \
tst-basic1 tst-basic2 tst-basic3 tst-basic4 tst-basic5 tst-basic6 \
tst-basic7 \
tst-mutex1 tst-mutex2 tst-mutex3 tst-mutex4 tst-mutex6 tst-mutex10 \

305
sysdeps/pthread/tst-attr1.c Normal file
View File

@ -0,0 +1,305 @@
/* Copyright (C) 2003-2020 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int
do_test (void)
{
int i;
pthread_attr_t a;
if (pthread_attr_init (&a) != 0)
{
puts ("attr_init failed");
exit (1);
}
pthread_mutexattr_t ma;
if (pthread_mutexattr_init (&ma) != 0)
{
puts ("mutexattr_init failed");
exit (1);
}
pthread_rwlockattr_t rwa;
if (pthread_rwlockattr_init (&rwa) != 0)
{
puts ("rwlockattr_init failed");
exit (1);
}
/* XXX Remove if default value is clear. */
pthread_attr_setinheritsched (&a, PTHREAD_INHERIT_SCHED);
pthread_attr_setschedpolicy (&a, SCHED_OTHER);
pthread_attr_setscope (&a, PTHREAD_SCOPE_SYSTEM);
for (i = 0; i < 10000; ++i)
{
long int r = random ();
if (r != PTHREAD_CREATE_DETACHED && r != PTHREAD_CREATE_JOINABLE)
{
int e = pthread_attr_setdetachstate (&a, r);
if (e == 0)
{
printf ("attr_setdetachstate with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("attr_setdetachstate didn't return EINVAL");
exit (1);
}
int s;
if (pthread_attr_getdetachstate (&a, &s) != 0)
{
puts ("attr_getdetachstate failed");
exit (1);
}
if (s != PTHREAD_CREATE_JOINABLE)
{
printf ("\
detach state changed to %d by invalid setdetachstate call\n", s);
exit (1);
}
}
if (r != PTHREAD_INHERIT_SCHED && r != PTHREAD_EXPLICIT_SCHED)
{
int e = pthread_attr_setinheritsched (&a, r);
if (e == 0)
{
printf ("attr_setinheritsched with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("attr_setinheritsched didn't return EINVAL");
exit (1);
}
int s;
if (pthread_attr_getinheritsched (&a, &s) != 0)
{
puts ("attr_getinheritsched failed");
exit (1);
}
if (s != PTHREAD_INHERIT_SCHED)
{
printf ("\
inheritsched changed to %d by invalid setinheritsched call\n", s);
exit (1);
}
}
if (r != SCHED_OTHER && r != SCHED_RR && r != SCHED_FIFO)
{
int e = pthread_attr_setschedpolicy (&a, r);
if (e == 0)
{
printf ("attr_setschedpolicy with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("attr_setschedpolicy didn't return EINVAL");
exit (1);
}
int s;
if (pthread_attr_getschedpolicy (&a, &s) != 0)
{
puts ("attr_getschedpolicy failed");
exit (1);
}
if (s != SCHED_OTHER)
{
printf ("\
schedpolicy changed to %d by invalid setschedpolicy call\n", s);
exit (1);
}
}
if (r != PTHREAD_SCOPE_SYSTEM && r != PTHREAD_SCOPE_PROCESS)
{
int e = pthread_attr_setscope (&a, r);
if (e == 0)
{
printf ("attr_setscope with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("attr_setscope didn't return EINVAL");
exit (1);
}
int s;
if (pthread_attr_getscope (&a, &s) != 0)
{
puts ("attr_getscope failed");
exit (1);
}
if (s != PTHREAD_SCOPE_SYSTEM)
{
printf ("\
contentionscope changed to %d by invalid setscope call\n", s);
exit (1);
}
}
if (r != PTHREAD_PROCESS_PRIVATE && r != PTHREAD_PROCESS_SHARED)
{
int e = pthread_mutexattr_setpshared (&ma, r);
if (e == 0)
{
printf ("mutexattr_setpshared with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("mutexattr_setpshared didn't return EINVAL");
exit (1);
}
int s;
if (pthread_mutexattr_getpshared (&ma, &s) != 0)
{
puts ("mutexattr_getpshared failed");
exit (1);
}
if (s != PTHREAD_PROCESS_PRIVATE)
{
printf ("\
pshared changed to %d by invalid mutexattr_setpshared call\n", s);
exit (1);
}
e = pthread_rwlockattr_setpshared (&rwa, r);
if (e == 0)
{
printf ("rwlockattr_setpshared with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("rwlockattr_setpshared didn't return EINVAL");
exit (1);
}
if (pthread_rwlockattr_getpshared (&rwa, &s) != 0)
{
puts ("rwlockattr_getpshared failed");
exit (1);
}
if (s != PTHREAD_PROCESS_PRIVATE)
{
printf ("\
pshared changed to %d by invalid rwlockattr_setpshared call\n", s);
exit (1);
}
}
if (r != PTHREAD_CANCEL_ENABLE && r != PTHREAD_CANCEL_DISABLE)
{
int e = pthread_setcancelstate (r, NULL);
if (e == 0)
{
printf ("setcancelstate with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("setcancelstate didn't return EINVAL");
exit (1);
}
int s;
if (pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, &s) != 0)
{
puts ("setcancelstate failed for PTHREAD_CANCEL_ENABLE");
exit (1);
}
if (s != PTHREAD_CANCEL_ENABLE)
{
puts ("invalid setcancelstate changed state");
exit (1);
}
}
if (r != PTHREAD_CANCEL_DEFERRED && r != PTHREAD_CANCEL_ASYNCHRONOUS)
{
int e = pthread_setcanceltype (r, NULL);
if (e == 0)
{
printf ("setcanceltype with value %ld succeeded\n", r);
exit (1);
}
if (e != EINVAL)
{
puts ("setcanceltype didn't return EINVAL");
exit (1);
}
int s;
if (pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &s) != 0)
{
puts ("setcanceltype failed for PTHREAD_CANCEL_DEFERRED");
exit (1);
}
if (s != PTHREAD_CANCEL_DEFERRED)
{
puts ("invalid setcanceltype changed state");
exit (1);
}
}
}
return 0;
}
#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"