LCOV - code coverage report
Current view: top level - gltests - test-stdint.c (source / functions) Hit Total Coverage
Test: GNU Libidn Lines: 2 2 100.0 %
Date: 2013-07-10 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Test of <stdint.h> substitute.
       2                 :            :    Copyright (C) 2006-2013 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    This program is free software: you can redistribute it and/or modify
       5                 :            :    it under the terms of the GNU General Public License as published by
       6                 :            :    the Free Software Foundation; either version 3 of the License, or
       7                 :            :    (at your option) any later version.
       8                 :            : 
       9                 :            :    This program is distributed in the hope that it will be useful,
      10                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      11                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12                 :            :    GNU General Public License for more details.
      13                 :            : 
      14                 :            :    You should have received a copy of the GNU General Public License
      15                 :            :    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
      16                 :            : 
      17                 :            : /* Written by Bruno Haible <bruno@clisp.org>, 2006.  */
      18                 :            : 
      19                 :            : #include <config.h>
      20                 :            : 
      21                 :            : /* Whether to enable pedantic checks. */
      22                 :            : #define DO_PEDANTIC 0
      23                 :            : 
      24                 :            : #include <stdint.h>
      25                 :            : 
      26                 :            : #include "verify.h"
      27                 :            : #include "intprops.h"
      28                 :            : 
      29                 :            : #if __GNUC__ >= 2 && DO_PEDANTIC
      30                 :            : # define verify_same_types(expr1,expr2)  \
      31                 :            :     extern void _verify_func(__LINE__) (__typeof__ (expr1) *); \
      32                 :            :     extern void _verify_func(__LINE__) (__typeof__ (expr2) *);
      33                 :            : # define _verify_func(line) _verify_func2(line)
      34                 :            : # define _verify_func2(line) verify_func_ ## line
      35                 :            : #else
      36                 :            : # define verify_same_types(expr1,expr2) extern void verify_func (int)
      37                 :            : #endif
      38                 :            : 
      39                 :            : /* 7.18.1.1. Exact-width integer types */
      40                 :            : /* 7.18.2.1. Limits of exact-width integer types */
      41                 :            : 
      42                 :            : int8_t a1[3] = { INT8_C (17), INT8_MIN, INT8_MAX };
      43                 :            : verify (TYPE_MINIMUM (int8_t) == INT8_MIN);
      44                 :            : verify (TYPE_MAXIMUM (int8_t) == INT8_MAX);
      45                 :            : verify_same_types (INT8_MIN, (int8_t) 0 + 0);
      46                 :            : verify_same_types (INT8_MAX, (int8_t) 0 + 0);
      47                 :            : 
      48                 :            : int16_t a2[3] = { INT16_C (17), INT16_MIN, INT16_MAX };
      49                 :            : verify (TYPE_MINIMUM (int16_t) == INT16_MIN);
      50                 :            : verify (TYPE_MAXIMUM (int16_t) == INT16_MAX);
      51                 :            : verify_same_types (INT16_MIN, (int16_t) 0 + 0);
      52                 :            : verify_same_types (INT16_MAX, (int16_t) 0 + 0);
      53                 :            : 
      54                 :            : int32_t a3[3] = { INT32_C (17), INT32_MIN, INT32_MAX };
      55                 :            : verify (TYPE_MINIMUM (int32_t) == INT32_MIN);
      56                 :            : verify (TYPE_MAXIMUM (int32_t) == INT32_MAX);
      57                 :            : verify_same_types (INT32_MIN, (int32_t) 0 + 0);
      58                 :            : verify_same_types (INT32_MAX, (int32_t) 0 + 0);
      59                 :            : 
      60                 :            : #ifdef INT64_MAX
      61                 :            : int64_t a4[3] = { INT64_C (17), INT64_MIN, INT64_MAX };
      62                 :            : verify (TYPE_MINIMUM (int64_t) == INT64_MIN);
      63                 :            : verify (TYPE_MAXIMUM (int64_t) == INT64_MAX);
      64                 :            : verify_same_types (INT64_MIN, (int64_t) 0 + 0);
      65                 :            : verify_same_types (INT64_MAX, (int64_t) 0 + 0);
      66                 :            : #endif
      67                 :            : 
      68                 :            : uint8_t b1[2] = { UINT8_C (17), UINT8_MAX };
      69                 :            : verify (TYPE_MAXIMUM (uint8_t) == UINT8_MAX);
      70                 :            : verify_same_types (UINT8_MAX, (uint8_t) 0 + 0);
      71                 :            : 
      72                 :            : uint16_t b2[2] = { UINT16_C (17), UINT16_MAX };
      73                 :            : verify (TYPE_MAXIMUM (uint16_t) == UINT16_MAX);
      74                 :            : verify_same_types (UINT16_MAX, (uint16_t) 0 + 0);
      75                 :            : 
      76                 :            : uint32_t b3[2] = { UINT32_C (17), UINT32_MAX };
      77                 :            : verify (TYPE_MAXIMUM (uint32_t) == UINT32_MAX);
      78                 :            : verify_same_types (UINT32_MAX, (uint32_t) 0 + 0);
      79                 :            : 
      80                 :            : #ifdef UINT64_MAX
      81                 :            : uint64_t b4[2] = { UINT64_C (17), UINT64_MAX };
      82                 :            : verify (TYPE_MAXIMUM (uint64_t) == UINT64_MAX);
      83                 :            : verify_same_types (UINT64_MAX, (uint64_t) 0 + 0);
      84                 :            : #endif
      85                 :            : 
      86                 :            : #if INT8_MIN && INT8_MAX && INT16_MIN && INT16_MAX && INT32_MIN && INT32_MAX
      87                 :            : /* ok */
      88                 :            : #else
      89                 :            : err or;
      90                 :            : #endif
      91                 :            : 
      92                 :            : #if UINT8_MAX && UINT16_MAX && UINT32_MAX
      93                 :            : /* ok */
      94                 :            : #else
      95                 :            : err or;
      96                 :            : #endif
      97                 :            : 
      98                 :            : /* 7.18.1.2. Minimum-width integer types */
      99                 :            : /* 7.18.2.2. Limits of minimum-width integer types */
     100                 :            : 
     101                 :            : int_least8_t c1[3] = { 17, INT_LEAST8_MIN, INT_LEAST8_MAX };
     102                 :            : verify (TYPE_MINIMUM (int_least8_t) == INT_LEAST8_MIN);
     103                 :            : verify (TYPE_MAXIMUM (int_least8_t) == INT_LEAST8_MAX);
     104                 :            : verify_same_types (INT_LEAST8_MIN, (int_least8_t) 0 + 0);
     105                 :            : verify_same_types (INT_LEAST8_MAX, (int_least8_t) 0 + 0);
     106                 :            : 
     107                 :            : int_least16_t c2[3] = { 17, INT_LEAST16_MIN, INT_LEAST16_MAX };
     108                 :            : verify (TYPE_MINIMUM (int_least16_t) == INT_LEAST16_MIN);
     109                 :            : verify (TYPE_MAXIMUM (int_least16_t) == INT_LEAST16_MAX);
     110                 :            : verify_same_types (INT_LEAST16_MIN, (int_least16_t) 0 + 0);
     111                 :            : verify_same_types (INT_LEAST16_MAX, (int_least16_t) 0 + 0);
     112                 :            : 
     113                 :            : int_least32_t c3[3] = { 17, INT_LEAST32_MIN, INT_LEAST32_MAX };
     114                 :            : verify (TYPE_MINIMUM (int_least32_t) == INT_LEAST32_MIN);
     115                 :            : verify (TYPE_MAXIMUM (int_least32_t) == INT_LEAST32_MAX);
     116                 :            : verify_same_types (INT_LEAST32_MIN, (int_least32_t) 0 + 0);
     117                 :            : verify_same_types (INT_LEAST32_MAX, (int_least32_t) 0 + 0);
     118                 :            : 
     119                 :            : #ifdef INT_LEAST64_MAX
     120                 :            : int_least64_t c4[3] = { 17, INT_LEAST64_MIN, INT_LEAST64_MAX };
     121                 :            : verify (TYPE_MINIMUM (int_least64_t) == INT_LEAST64_MIN);
     122                 :            : verify (TYPE_MAXIMUM (int_least64_t) == INT_LEAST64_MAX);
     123                 :            : verify_same_types (INT_LEAST64_MIN, (int_least64_t) 0 + 0);
     124                 :            : verify_same_types (INT_LEAST64_MAX, (int_least64_t) 0 + 0);
     125                 :            : #endif
     126                 :            : 
     127                 :            : uint_least8_t d1[2] = { 17, UINT_LEAST8_MAX };
     128                 :            : verify (TYPE_MAXIMUM (uint_least8_t) == UINT_LEAST8_MAX);
     129                 :            : verify_same_types (UINT_LEAST8_MAX, (uint_least8_t) 0 + 0);
     130                 :            : 
     131                 :            : uint_least16_t d2[2] = { 17, UINT_LEAST16_MAX };
     132                 :            : verify (TYPE_MAXIMUM (uint_least16_t) == UINT_LEAST16_MAX);
     133                 :            : verify_same_types (UINT_LEAST16_MAX, (uint_least16_t) 0 + 0);
     134                 :            : 
     135                 :            : uint_least32_t d3[2] = { 17, UINT_LEAST32_MAX };
     136                 :            : verify (TYPE_MAXIMUM (uint_least32_t) == UINT_LEAST32_MAX);
     137                 :            : verify_same_types (UINT_LEAST32_MAX, (uint_least32_t) 0 + 0);
     138                 :            : 
     139                 :            : #ifdef UINT_LEAST64_MAX
     140                 :            : uint_least64_t d4[2] = { 17, UINT_LEAST64_MAX };
     141                 :            : verify (TYPE_MAXIMUM (uint_least64_t) == UINT_LEAST64_MAX);
     142                 :            : verify_same_types (UINT_LEAST64_MAX, (uint_least64_t) 0 + 0);
     143                 :            : #endif
     144                 :            : 
     145                 :            : #if INT_LEAST8_MIN && INT_LEAST8_MAX && INT_LEAST16_MIN && INT_LEAST16_MAX && INT_LEAST32_MIN && INT_LEAST32_MAX
     146                 :            : /* ok */
     147                 :            : #else
     148                 :            : err or;
     149                 :            : #endif
     150                 :            : 
     151                 :            : #if UINT_LEAST8_MAX && UINT_LEAST16_MAX && UINT_LEAST32_MAX
     152                 :            : /* ok */
     153                 :            : #else
     154                 :            : err or;
     155                 :            : #endif
     156                 :            : 
     157                 :            : /* 7.18.1.3. Fastest minimum-width integer types */
     158                 :            : /* 7.18.2.3. Limits of fastest minimum-width integer types */
     159                 :            : 
     160                 :            : int_fast8_t e1[3] = { 17, INT_FAST8_MIN, INT_FAST8_MAX };
     161                 :            : verify (TYPE_MINIMUM (int_fast8_t) == INT_FAST8_MIN);
     162                 :            : verify (TYPE_MAXIMUM (int_fast8_t) == INT_FAST8_MAX);
     163                 :            : verify_same_types (INT_FAST8_MIN, (int_fast8_t) 0 + 0);
     164                 :            : verify_same_types (INT_FAST8_MAX, (int_fast8_t) 0 + 0);
     165                 :            : 
     166                 :            : int_fast16_t e2[3] = { 17, INT_FAST16_MIN, INT_FAST16_MAX };
     167                 :            : verify (TYPE_MINIMUM (int_fast16_t) == INT_FAST16_MIN);
     168                 :            : verify (TYPE_MAXIMUM (int_fast16_t) == INT_FAST16_MAX);
     169                 :            : verify_same_types (INT_FAST16_MIN, (int_fast16_t) 0 + 0);
     170                 :            : verify_same_types (INT_FAST16_MAX, (int_fast16_t) 0 + 0);
     171                 :            : 
     172                 :            : int_fast32_t e3[3] = { 17, INT_FAST32_MIN, INT_FAST32_MAX };
     173                 :            : verify (TYPE_MINIMUM (int_fast32_t) == INT_FAST32_MIN);
     174                 :            : verify (TYPE_MAXIMUM (int_fast32_t) == INT_FAST32_MAX);
     175                 :            : verify_same_types (INT_FAST32_MIN, (int_fast32_t) 0 + 0);
     176                 :            : verify_same_types (INT_FAST32_MAX, (int_fast32_t) 0 + 0);
     177                 :            : 
     178                 :            : #ifdef INT_FAST64_MAX
     179                 :            : int_fast64_t e4[3] = { 17, INT_FAST64_MIN, INT_FAST64_MAX };
     180                 :            : verify (TYPE_MINIMUM (int_fast64_t) == INT_FAST64_MIN);
     181                 :            : verify (TYPE_MAXIMUM (int_fast64_t) == INT_FAST64_MAX);
     182                 :            : verify_same_types (INT_FAST64_MIN, (int_fast64_t) 0 + 0);
     183                 :            : verify_same_types (INT_FAST64_MAX, (int_fast64_t) 0 + 0);
     184                 :            : #endif
     185                 :            : 
     186                 :            : uint_fast8_t f1[2] = { 17, UINT_FAST8_MAX };
     187                 :            : verify (TYPE_MAXIMUM (uint_fast8_t) == UINT_FAST8_MAX);
     188                 :            : verify_same_types (UINT_FAST8_MAX, (uint_fast8_t) 0 + 0);
     189                 :            : 
     190                 :            : uint_fast16_t f2[2] = { 17, UINT_FAST16_MAX };
     191                 :            : verify (TYPE_MAXIMUM (uint_fast16_t) == UINT_FAST16_MAX);
     192                 :            : verify_same_types (UINT_FAST16_MAX, (uint_fast16_t) 0 + 0);
     193                 :            : 
     194                 :            : uint_fast32_t f3[2] = { 17, UINT_FAST32_MAX };
     195                 :            : verify (TYPE_MAXIMUM (uint_fast32_t) == UINT_FAST32_MAX);
     196                 :            : verify_same_types (UINT_FAST32_MAX, (uint_fast32_t) 0 + 0);
     197                 :            : 
     198                 :            : #ifdef UINT_FAST64_MAX
     199                 :            : uint_fast64_t f4[2] = { 17, UINT_FAST64_MAX };
     200                 :            : verify (TYPE_MAXIMUM (uint_fast64_t) == UINT_FAST64_MAX);
     201                 :            : verify_same_types (UINT_FAST64_MAX, (uint_fast64_t) 0 + 0);
     202                 :            : #endif
     203                 :            : 
     204                 :            : #if INT_FAST8_MIN && INT_FAST8_MAX && INT_FAST16_MIN && INT_FAST16_MAX && INT_FAST32_MIN && INT_FAST32_MAX
     205                 :            : /* ok */
     206                 :            : #else
     207                 :            : err or;
     208                 :            : #endif
     209                 :            : 
     210                 :            : #if UINT_FAST8_MAX && UINT_FAST16_MAX && UINT_FAST32_MAX
     211                 :            : /* ok */
     212                 :            : #else
     213                 :            : err or;
     214                 :            : #endif
     215                 :            : 
     216                 :            : /* 7.18.1.4. Integer types capable of holding object pointers */
     217                 :            : /* 7.18.2.4. Limits of integer types capable of holding object pointers */
     218                 :            : 
     219                 :            : intptr_t g[3] = { 17, INTPTR_MIN, INTPTR_MAX };
     220                 :            : verify (TYPE_MINIMUM (intptr_t) == INTPTR_MIN);
     221                 :            : verify (TYPE_MAXIMUM (intptr_t) == INTPTR_MAX);
     222                 :            : verify_same_types (INTPTR_MIN, (intptr_t) 0 + 0);
     223                 :            : verify_same_types (INTPTR_MAX, (intptr_t) 0 + 0);
     224                 :            : 
     225                 :            : uintptr_t h[2] = { 17, UINTPTR_MAX };
     226                 :            : verify (TYPE_MAXIMUM (uintptr_t) == UINTPTR_MAX);
     227                 :            : verify_same_types (UINTPTR_MAX, (uintptr_t) 0 + 0);
     228                 :            : 
     229                 :            : #if INTPTR_MIN && INTPTR_MAX && UINTPTR_MAX
     230                 :            : /* ok */
     231                 :            : #else
     232                 :            : err or;
     233                 :            : #endif
     234                 :            : 
     235                 :            : /* 7.18.1.5. Greatest-width integer types */
     236                 :            : /* 7.18.2.5. Limits of greatest-width integer types */
     237                 :            : 
     238                 :            : intmax_t i[3] = { INTMAX_C (17), INTMAX_MIN, INTMAX_MAX };
     239                 :            : verify (TYPE_MINIMUM (intmax_t) == INTMAX_MIN);
     240                 :            : verify (TYPE_MAXIMUM (intmax_t) == INTMAX_MAX);
     241                 :            : verify_same_types (INTMAX_MIN, (intmax_t) 0 + 0);
     242                 :            : verify_same_types (INTMAX_MAX, (intmax_t) 0 + 0);
     243                 :            : 
     244                 :            : uintmax_t j[2] = { UINTMAX_C (17), UINTMAX_MAX };
     245                 :            : verify (TYPE_MAXIMUM (uintmax_t) == UINTMAX_MAX);
     246                 :            : verify_same_types (UINTMAX_MAX, (uintmax_t) 0 + 0);
     247                 :            : 
     248                 :            : /* As of 2007, Sun C and HP-UX 10.20 cc don't support 'long long' constants in
     249                 :            :    the preprocessor.  */
     250                 :            : #if !(defined __SUNPRO_C || (defined __hpux && !defined __GNUC__))
     251                 :            : #if INTMAX_MIN && INTMAX_MAX && UINTMAX_MAX
     252                 :            : /* ok */
     253                 :            : #else
     254                 :            : err or;
     255                 :            : #endif
     256                 :            : #endif
     257                 :            : 
     258                 :            : /* 7.18.3. Limits of other integer types */
     259                 :            : 
     260                 :            : #include <stddef.h>
     261                 :            : 
     262                 :            : verify (TYPE_MINIMUM (ptrdiff_t) == PTRDIFF_MIN);
     263                 :            : verify (TYPE_MAXIMUM (ptrdiff_t) == PTRDIFF_MAX);
     264                 :            : verify_same_types (PTRDIFF_MIN, (ptrdiff_t) 0 + 0);
     265                 :            : verify_same_types (PTRDIFF_MAX, (ptrdiff_t) 0 + 0);
     266                 :            : 
     267                 :            : #if PTRDIFF_MIN && PTRDIFF_MAX
     268                 :            : /* ok */
     269                 :            : #else
     270                 :            : err or;
     271                 :            : #endif
     272                 :            : 
     273                 :            : #include <signal.h>
     274                 :            : 
     275                 :            : verify (TYPE_MINIMUM (sig_atomic_t) == SIG_ATOMIC_MIN);
     276                 :            : verify (TYPE_MAXIMUM (sig_atomic_t) == SIG_ATOMIC_MAX);
     277                 :            : verify_same_types (SIG_ATOMIC_MIN, (sig_atomic_t) 0 + 0);
     278                 :            : verify_same_types (SIG_ATOMIC_MAX, (sig_atomic_t) 0 + 0);
     279                 :            : 
     280                 :            : #if SIG_ATOMIC_MIN != 17 && SIG_ATOMIC_MAX
     281                 :            : /* ok */
     282                 :            : #else
     283                 :            : err or;
     284                 :            : #endif
     285                 :            : 
     286                 :            : verify (TYPE_MAXIMUM (size_t) == SIZE_MAX);
     287                 :            : verify_same_types (SIZE_MAX, (size_t) 0 + 0);
     288                 :            : 
     289                 :            : #if SIZE_MAX
     290                 :            : /* ok */
     291                 :            : #else
     292                 :            : err or;
     293                 :            : #endif
     294                 :            : 
     295                 :            : #if HAVE_WCHAR_T
     296                 :            : verify (TYPE_MINIMUM (wchar_t) == WCHAR_MIN);
     297                 :            : verify (TYPE_MAXIMUM (wchar_t) == WCHAR_MAX);
     298                 :            : verify_same_types (WCHAR_MIN, (wchar_t) 0 + 0);
     299                 :            : verify_same_types (WCHAR_MAX, (wchar_t) 0 + 0);
     300                 :            : 
     301                 :            : # if WCHAR_MIN != 17 && WCHAR_MAX
     302                 :            : /* ok */
     303                 :            : # else
     304                 :            : err or;
     305                 :            : # endif
     306                 :            : #endif
     307                 :            : 
     308                 :            : #if HAVE_WINT_T
     309                 :            : # include <wchar.h>
     310                 :            : 
     311                 :            : verify (TYPE_MINIMUM (wint_t) == WINT_MIN);
     312                 :            : verify (TYPE_MAXIMUM (wint_t) == WINT_MAX);
     313                 :            : verify_same_types (WINT_MIN, (wint_t) 0 + 0);
     314                 :            : verify_same_types (WINT_MAX, (wint_t) 0 + 0);
     315                 :            : 
     316                 :            : # if WINT_MIN != 17 && WINT_MAX
     317                 :            : /* ok */
     318                 :            : # else
     319                 :            : err or;
     320                 :            : # endif
     321                 :            : #endif
     322                 :            : 
     323                 :            : /* 7.18.4. Macros for integer constants */
     324                 :            : 
     325                 :            : verify (INT8_C (17) == 17);
     326                 :            : verify_same_types (INT8_C (17), (int_least8_t)0 + 0);
     327                 :            : verify (UINT8_C (17) == 17);
     328                 :            : verify_same_types (UINT8_C (17), (uint_least8_t)0 + 0);
     329                 :            : 
     330                 :            : verify (INT16_C (17) == 17);
     331                 :            : verify_same_types (INT16_C (17), (int_least16_t)0 + 0);
     332                 :            : verify (UINT16_C (17) == 17);
     333                 :            : verify_same_types (UINT16_C (17), (uint_least16_t)0 + 0);
     334                 :            : 
     335                 :            : verify (INT32_C (17) == 17);
     336                 :            : verify_same_types (INT32_C (17), (int_least32_t)0 + 0);
     337                 :            : verify (UINT32_C (17) == 17);
     338                 :            : verify_same_types (UINT32_C (17), (uint_least32_t)0 + 0);
     339                 :            : 
     340                 :            : #ifdef INT64_C
     341                 :            : verify (INT64_C (17) == 17);
     342                 :            : verify_same_types (INT64_C (17), (int_least64_t)0 + 0);
     343                 :            : #endif
     344                 :            : #ifdef UINT64_C
     345                 :            : verify (UINT64_C (17) == 17);
     346                 :            : verify_same_types (UINT64_C (17), (uint_least64_t)0 + 0);
     347                 :            : #endif
     348                 :            : 
     349                 :            : verify (INTMAX_C (17) == 17);
     350                 :            : verify_same_types (INTMAX_C (17), (intmax_t)0 + 0);
     351                 :            : verify (UINTMAX_C (17) == 17);
     352                 :            : verify_same_types (UINTMAX_C (17), (uintmax_t)0 + 0);
     353                 :            : 
     354                 :            : 
     355                 :            : int
     356                 :          1 : main (void)
     357                 :            : {
     358                 :          1 :   return 0;
     359                 :            : }

Generated by: LCOV version 1.9