Smack: add the execute lable to ldconfig

[platform/upstream/glibc.git] / rt / tst-cpuclock2.c

diff --git a/rt/tst-cpuclock2.c b/rt/tst-cpuclock2.c
index d1621f3..fb07655 100644 (file)
--- a/rt/tst-cpuclock2.c
+++ b/rt/tst-cpuclock2.c
@@ -1,5 +1,5 @@
 /* Test program for process and thread CPU clocks.
-   Copyright (C) 2005 Free Software Foundation, Inc.
+   Copyright (C) 2005-2015 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -13,11 +13,11 @@
    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 <unistd.h>
+#include <stdint.h>
 
 #if (_POSIX_THREADS - 0) <= 0
 
@@ -111,7 +111,7 @@ test_nanosleep (clockid_t clock, const char *which,
   struct timespec sleeptimeabs = sleeptime;
   sleeptimeabs.tv_sec += after.tv_sec;
   sleeptimeabs.tv_nsec += after.tv_nsec;
-  while (sleeptimeabs.tv_nsec > 1000000000)
+  while (sleeptimeabs.tv_nsec >= 1000000000)
     {
       ++sleeptimeabs.tv_sec;
       sleeptimeabs.tv_nsec -= 1000000000;
@@ -217,19 +217,20 @@ do_test (void)
   struct timespec res;
   if (clock_getres (th_clock, &res) < 0)
     {
-      printf ("clock_getres on thread clock %lx => %s\n",
+      printf ("clock_getres on live thread clock %lx => %s\n",
              (unsigned long int) th_clock, strerror (errno));
       result = 1;
       return 1;
     }
-  printf ("live thread clock %lx resolution %lu.%.9lu\n",
-         (unsigned long int) th_clock, res.tv_sec, res.tv_nsec);
+  printf ("live thread clock %lx resolution %ju.%.9ju\n",
+         (unsigned long int) th_clock,
+         (uintmax_t) res.tv_sec, (uintmax_t) res.tv_nsec);
 
   struct timespec process_before, process_after;
   if (clock_gettime (process_clock, &process_before) < 0)
     {
       printf ("clock_gettime on process clock %lx => %s\n",
-             (unsigned long int) th_clock, strerror (errno));
+             (unsigned long int) process_clock, strerror (errno));
       return 1;
     }
 
@@ -240,21 +241,25 @@ do_test (void)
              (unsigned long int) th_clock, strerror (errno));
       return 1;
     }
-  printf ("live thread before sleep => %lu.%.9lu\n",
-         before.tv_sec, before.tv_nsec);
+  printf ("live thread before sleep => %ju.%.9ju\n",
+         (uintmax_t) before.tv_sec, (uintmax_t) before.tv_nsec);
 
   struct timespec me_before, me_after;
   if (clock_gettime (my_thread_clock, &me_before) < 0)
     {
-      printf ("clock_gettime on live thread clock %lx => %s\n",
-             (unsigned long int) th_clock, strerror (errno));
+      printf ("clock_gettime on self thread clock %lx => %s\n",
+             (unsigned long int) my_thread_clock, strerror (errno));
       return 1;
     }
-  printf ("self thread before sleep => %lu.%.9lu\n",
-         me_before.tv_sec, me_before.tv_nsec);
+  printf ("self thread before sleep => %ju.%.9ju\n",
+         (uintmax_t) me_before.tv_sec, (uintmax_t) me_before.tv_nsec);
 
   struct timespec sleeptime = { .tv_nsec = 500000000 };
-  nanosleep (&sleeptime, NULL);
+  if (nanosleep (&sleeptime, NULL) != 0)
+    {
+      perror ("nanosleep");
+      return 1;
+    }
 
   if (clock_gettime (th_clock, &after) < 0)
     {
@@ -262,24 +267,24 @@ do_test (void)
              (unsigned long int) th_clock, strerror (errno));
       return 1;
     }
-  printf ("live thread after sleep => %lu.%.9lu\n",
-         after.tv_sec, after.tv_nsec);
+  printf ("live thread after sleep => %ju.%.9ju\n",
+         (uintmax_t) after.tv_sec, (uintmax_t) after.tv_nsec);
 
   if (clock_gettime (process_clock, &process_after) < 0)
     {
       printf ("clock_gettime on process clock %lx => %s\n",
-             (unsigned long int) th_clock, strerror (errno));
+             (unsigned long int) process_clock, strerror (errno));
       return 1;
     }
 
   if (clock_gettime (my_thread_clock, &me_after) < 0)
     {
-      printf ("clock_gettime on live thread clock %lx => %s\n",
-             (unsigned long int) th_clock, strerror (errno));
+      printf ("clock_gettime on self thread clock %lx => %s\n",
+             (unsigned long int) my_thread_clock, strerror (errno));
       return 1;
     }
-  printf ("self thread after sleep => %lu.%.9lu\n",
-         me_after.tv_sec, me_after.tv_nsec);
+  printf ("self thread after sleep => %ju.%.9ju\n",
+         (uintmax_t) me_after.tv_sec, (uintmax_t) me_after.tv_nsec);
 
   unsigned long long int th_diff = tsdiff (&before, &after);
   unsigned long long int pdiff = tsdiff (&process_before, &process_after);
@@ -287,7 +292,7 @@ do_test (void)
 
   if (th_diff < 100000000 || th_diff > 600000000)
     {
-      printf ("thread before - after %llu outside reasonable range\n",
+      printf ("live thread before - after %llu outside reasonable range\n",
              th_diff);
       result = 1;
     }
@@ -306,7 +311,7 @@ do_test (void)
       result = 1;
     }
 
-  process_after.tv_nsec += test_nanosleep (th_clock, "thread",
+  process_after.tv_nsec += test_nanosleep (th_clock, "live thread",
                                           &after, &result);
   process_after.tv_nsec += test_nanosleep (process_clock, "process",
                                           &process_after, &result);