/************************************************************************
 *
 * 18.c.limits.stdcxx-988.cpp - regression test for STDCXX-988
 *
 * http://issues.apache.org/jira/browse/STDCXX-988
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 * 
 **************************************************************************/

#include <cassert>
#include <limits.h>


int main ()
{
#if    (defined __unix__ || defined __unix || defined unix) \
    && !defined _RWSTD_EDG_ECCP

    // According to POSIX (SUSv3), the following macros are required
    // to be defined in <limits.h> (others, such as OPEN_MAX) are
    // optional):
    // http://www.opengroup.org/onlinepubs/009695399/basedefs/limits.h.html

    // Runtime Increasable Values

    // The magnitude limitations in the following list shall be fixed
    // by specific implementations. An application should assume that
    // the value supplied by <limits.h> in a specific implementation
    // is the minimum that pertains whenever the application is run
    // under that implementation. A specific instance of a specific
    // implementation may increase the value relative to that supplied
    // by <limits.h> for that implementation. The actual value supported
    // by a specific instance shall be provided by the sysconf() function.

    assert (BC_BASE_MAX        != 0 /* >= _POSIX2_BC_BASE_MAX */ );
    assert (BC_DIM_MAX         != 0 /* >= _POSIX2_BC_DIM_MAX */ );
    assert (BC_SCALE_MAX       != 0 /* >= _POSIX2_BC_SCALE_MAX */ );
    assert (BC_STRING_MAX      != 0 /* >= _POSIX2_BC_STRING_MAX */ );
    assert (CHARCLASS_NAME_MAX != 0 /* >= _POSIX2_CHARCLASS_NAME_MAX */ );
    assert (COLL_WEIGHTS_MAX   != 0 /* >= _POSIX2_COLL_WEIGHTS_MAX */ );
    assert (EXPR_NEST_MAX      != 0 /* >= _POSIX2_EXPR_NEST_MAX */ );
    assert (LINE_MAX           != 0 /* >= _POSIX2_LINE_MAX */ );
    assert (NGROUPS_MAX        != 0 /* >= _POSIX_NGROUPS_MAX */ );
    assert (RE_DUP_MAX         != 0 /* >= _POSIX2_RE_DUP_MAX */ );

    // Minimum Values

    // The symbolic constants in the following list shall be defined
    // in <limits.h> with the values shown. These are symbolic names
    // for the most restrictive value for certain features on an
    // implementation conforming to this volume of IEEE Std 1003.1-2001.
    // Related symbolic constants are defined elsewhere in this volume
    // of IEEE Std 1003.1-2001 which reflect the actual implementation
    // and which need not be as restrictive. A conforming implementation
    // shall provide values at least this large. A strictly conforming
    // application must not require a larger value for correct operation.

    // avoid testing specific values since they're not important here
    // all we care is that the macros be defined (i.e., that thet are
    // not somehow hidden or #undef'd by our implementation)

    assert (_POSIX_ARG_MAX        != 0 /* ==  4096 */);
    assert (_POSIX_CHILD_MAX      != 0 /* ==    25 */);
    assert (_POSIX_HOST_NAME_MAX  != 0 /* ==   255 */);
    assert (_POSIX_LINK_MAX       != 0 /* ==     8 */);
    assert (_POSIX_LOGIN_NAME_MAX != 0 /* ==     9 */);
    assert (_POSIX_MAX_CANON      != 0 /* ==   255 */);
    assert (_POSIX_MAX_INPUT      != 0 /* ==   255 */);
    assert (_POSIX_NAME_MAX       != 0 /* ==    14 */);
    assert (_POSIX_NGROUPS_MAX    != 0 /* ==     8 */);
    assert (_POSIX_OPEN_MAX       != 0 /* ==    20 */);
    assert (_POSIX_PATH_MAX       != 0 /* ==   256 */);
    assert (_POSIX_PIPE_BUF       != 0 /* ==   512 */);
    assert (_POSIX_RE_DUP_MAX     != 0 /* ==   255 */);
    assert (_POSIX_SSIZE_MAX      != 0 /* == 32767 */);
    assert (_POSIX_STREAM_MAX     != 0 /* ==     8 */);
    assert (_POSIX_SYMLINK_MAX    != 0 /* ==   255 */);
    assert (_POSIX_SYMLOOP_MAX    != 0 /* ==     8 */);
    assert (_POSIX_TTY_NAME_MAX   != 0 /* ==     9 */);
    assert (_POSIX_TZNAME_MAX     != 0 /* ==     6 */);

#  ifdef _POSIX2_VERSION

    assert (_POSIX2_BC_BASE_MAX        != 0 /* ==   99 */);
    assert (_POSIX2_BC_DIM_MAX         != 0 /* == 2048 */);
    assert (_POSIX2_BC_SCALE_MAX       != 0 /* ==   99 */);
    assert (_POSIX2_BC_STRING_MAX      != 0 /* == 1000 */);
    assert (_POSIX2_CHARCLASS_NAME_MAX != 0 /* ==   14 */);
    assert (_POSIX2_COLL_WEIGHTS_MAX   != 0 /* ==    2 */);
    assert (_POSIX2_EXPR_NEST_MAX      != 0 /* ==   32 */);
    assert (_POSIX2_LINE_MAX           != 0 /* == 2048 */);
    assert (_POSIX2_RE_DUP_MAX         != 0 /* ==  255 */);

#  endif   // _POSIX2_VERSION

#endif   // UNIX && !EDG eccp

    // Numerical Limits

    // The values in the following lists shall be defined in <limits.h>
    // and are constant expressions suitable for use in #if preprocessing
    // directives. Moreover, except for {CHAR_BIT}, {DBL_DIG}, {DBL_MAX},
    // {FLT_DIG}, {FLT_MAX}, {LONG_BIT}, {WORD_BIT}, and {MB_LEN_MAX},
    // the symbolic names are defined as expressions of the correct type.

    // If the value of an object of type char is treated as a signed
    // integer when used in an expression, the value of {CHAR_MIN} is
    // the same as that of {SCHAR_MIN} and the value of {CHAR_MAX} is
    // the same as that of {SCHAR_MAX}. Otherwise, the value of
    // {CHAR_MIN} is 0 and the value of {CHAR_MAX} is the same as that
    // of {UCHAR_MAX}.

    assert (CHAR_BIT   == 8);
    assert (CHAR_MAX   == UCHAR_MAX || CHAR_MAX == SCHAR_MAX);
    assert (CHAR_MIN   == SCHAR_MIN || CHAR_MIN == 0);
    assert (INT_MAX    >= 2147483647);
    assert (LONG_MAX   >= +2147483647);
    assert (MB_LEN_MAX >= 1);
    assert (SCHAR_MAX  == +127);
    assert (SHRT_MAX   >= +32767);

#if !defined (_RWSTD_EDG_ECCP) && !defined (_MSC_VER)

    // avoid exercising with the EDG eccp front end (strict mode)
    assert (LONG_BIT   >= 32);
    assert (SSIZE_MAX  >= _POSIX_SSIZE_MAX);
    assert (WORD_BIT   >= 32);

#endif   // EDG eccp || MSVC || ICC/Windows

    assert (UCHAR_MAX  >= 255);
    assert (UINT_MAX   >= 4294967295);
    assert (ULONG_MAX  >= 4294967295);
    assert (USHRT_MAX  >= 65535);
    assert (INT_MIN    <= -2147483647);
    assert (LONG_MIN   != 0);
    assert (SCHAR_MIN  == -128);
    assert (SHRT_MIN   != 0);

#ifndef _RWSTD_NO_LONG_LONG

#  if !defined __HP_aCC || 199901L <= __STDC_VERSION__

    // HP aCC defines LLONG_MAX and LLONG_MIN only in C99 mode
    // i.e., with -AC99

    assert (LLONG_MIN  != 0);
    assert (LLONG_MAX  >= +9223372036854775807LL);
    assert (ULLONG_MAX >= 18446744073709551615ULL);

#  endif

#endif   // _RWSTD_NO_LONG_LONG

    return 0;
}