Add per-thread cache to malloc

[thirdparty/glibc.git] / nptl / tst-attr1.c

diff --git a/nptl/tst-attr1.c b/nptl/tst-attr1.c
index c5870beb5b7cc038457a1b0fa39a76e8dcf1b23b..1da7f3ba0105e1894bb922e7c41c5b24bb459fb2 100644 (file)
--- a/nptl/tst-attr1.c
+++ b/nptl/tst-attr1.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2003-2017 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
 
@@ -13,10 +13,10 @@
    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, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
 
+#include <errno.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -43,6 +43,14 @@ do_test (void)
       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);
@@ -61,6 +69,11 @@ do_test (void)
              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)
@@ -86,6 +99,11 @@ detach state changed to %d by invalid setdetachstate call\n", s);
              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)
@@ -111,6 +129,11 @@ inheritsched changed to %d by invalid setinheritsched call\n", s);
              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)
@@ -136,6 +159,11 @@ schedpolicy changed to %d by invalid setschedpolicy call\n", s);
              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)
@@ -161,6 +189,11 @@ contentionscope changed to %d by invalid setscope call\n", s);
              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)
@@ -175,6 +208,92 @@ contentionscope changed to %d by invalid setscope call\n", s);
 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);
+           }
        }
     }