/***************************************************************************
 *
 * pairs.cpp - test exercising [lib.pairs]
 *
 * $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.
 *
 * Copyright 2001-2006 Rogue Wave Software.
 * 
 **************************************************************************/

#include <utility>

#include <rw_alg_test.h>
#include <rw_value.h>   // for UserClass
#include <rw_driver.h>

/**************************************************************************/

struct Y: UserClass { };


int less_used;


_RWSTD_NAMESPACE (std) {

_RWSTD_SPECIALIZED_CLASS
bool less<Y>::operator() (const Y &a, const Y &b) const
{
    ++less_used;
    return a < b;
}

}   // namespace std


#ifndef _RWSTD_NO_EXPLICIT_CTOR_INSTANTIATION

typedef base<def_ctor> DefaultConstructible;
typedef base<cpy_ctor> CopyConstructible;

_RWSTD_NAMESPACE (std) {

// enclosing explicit instantiation within the declaring namespace
// instead of qualifying it with its name to work around compiler
// bugs (e.g., SunPro 5.4 -- see PR #28117)

#ifndef _RWSTD_NO_EMPTY_MEM_INITIALIZER

template pair<DefaultConstructible, DefaultConstructible>::pair ();

#endif  // _RWSTD_NO_EMPTY_MEM_INITIALIZER

template pair<CopyConstructible, CopyConstructible>::
         pair (const CopyConstructible&, const CopyConstructible&);

}   // namespace std

#endif   // _RWSTD_NO_EXPLICIT_CTOR_INSTANTIATION

/**************************************************************************/

template <class T, class U>
void test_pair (T, const char *tname, U, const char *uname)
{
    typedef std::pair<T, U> Pair;

    T *pt = (typename Pair::first_type*)0;
    U *pu = (typename Pair::second_type*)0;

    rw_info (0, 0, __LINE__, "std::pair<%s, %s> data members", tname, uname);

    if (0) {   // compile only

        // verify pair data members and their types
        Pair *p = 0;
        pt = &p->first;
        pu = &p->second;

        _RWSTD_UNUSED (pt);
        _RWSTD_UNUSED (pu);
    }

    if (0) {   // compile only
        Pair *p0 = 0;
        std::pair<long, double> p1 (*p0);

        _RWSTD_UNUSED (p1);
    }

    {
        rw_info (0, 0, __LINE__, "std::pair<%s, %s>::pair()", tname, uname);

        UserClass::reset_totals ();

        std::pair<Y, Y> py;

        rw_assert (UserClass::n_total_def_ctor_ == 2, 0, __LINE__,
                   "pair<Y, Y>::pair() called %d default ctors, "
                   "expected 2", UserClass::n_total_def_ctor_, 2);

#ifndef _RWSTD_NO_EMPTY_MEM_INITIALIZER

        // exercise lwg issue 265
        rw_assert (UserClass::n_total_copy_ctor_ == 0, 0, __LINE__,
                   "pair<Y, Y>::pair() called %d copy ctors, "
                   "expected 0", UserClass::n_total_copy_ctor_);

#else   // if defined (_RWSTD_NO_EMPTY_MEM_INITIALIZER)

        // 20.2.2, p2: commented out -- calls to copy ctor may be elided
        // RW_ASSERT (t, UserClass::n_total_copy_ctor_ == 2,
        //            ("std::pair<Y, Y>::pair() called %d copy ctors, "
        //            "expected 2", UserClass::n_total_copy_ctor_));

#endif   // _RWSTD_NO_EMPTY_MEM_INITIALIZER

        rw_info (0, 0, __LINE__,
                 "std::pair<%s, %s>::pair(const %s&, const %s&)",
                 tname, uname, tname, uname);

        UserClass x0;
        UserClass x1;

        UserClass::reset_totals ();

        // 20.2.2, p3
        std::pair<UserClass, UserClass> px0 (x0, x1);

        rw_assert (UserClass::n_total_copy_ctor_ == 2, 0, __LINE__,
                   "pair<T, U>::pair (const T&, const U&) called %d cpy "
                   "ctors, expected 2", UserClass::n_total_copy_ctor_);


        rw_info (0, 0, __LINE__,
                 "template <class T, class U> "
                 "std::pair<%s, %s>::pair(const pair<T, U>&)",
                 tname, uname);

        UserClass::reset_totals ();

        // 20.2.2, p4
        std::pair<UserClass, UserClass> px (py);

        rw_assert (UserClass::n_total_copy_ctor_ == 2, 0, __LINE__,
                   "template <class T, class U> pair<UserClass, "
                   "UserClass>::pair(const std::pair<T, U>&) called "
                   "%d cpy ctors, expected 2",
                   UserClass::n_total_copy_ctor_);


        rw_info (0, 0, __LINE__,
                 "template <class T, class U> "
                 "std::pair<%s, %s>::operator= (const pair<T, U>&)",
                 tname, uname);

        UserClass::reset_totals ();

        // exercise template assignment if provided,
        // otherwise template ctor and ordinary assignment
        px = py;

        rw_assert (UserClass::n_total_copy_ctor_ == 0, 0, __LINE__,
                   "template <class T, class U> pair<UserClass, "
                   "UserClass>::operator=(const pair<T, U>&) "
                   "called %d cpy ctors, expected 0",
                   UserClass::n_total_copy_ctor_);

        rw_assert (UserClass::n_total_op_assign_ == 2, 0, __LINE__,
                   "template <class T, class U> pair<UserClass, "
                   "UserClass>::operator=(const pair<T, U>&) "
                   "called %d assignment operators, "
                   "expected 2", UserClass::n_total_op_assign_);
    }

    {

// exercise the signature of a nonmember (or static member) function
#define FUN(result, name, arg_list) do {                                \
        rw_info (0, 0, __LINE__, "%s(const pair<%s, %s>&, "             \
                                  "const pair<%s, %s>&)", #name,        \
                                  tname, uname, tname, uname);          \
        /* make name unique to prevent bogus gcc -Wshadow warnings */   \
        result (*_RWSTD_PASTE (pf, __LINE__)) arg_list = &name;         \
        _RWSTD_UNUSED (_RWSTD_PASTE (pf, __LINE__));                    \
    } while (0)

        FUN (bool, std::operator==, (const Pair&, const Pair&));
        FUN (bool, std::operator!=, (const Pair&, const Pair&));
        FUN (bool, std::operator<,  (const Pair&, const Pair&));
        FUN (bool, std::operator<=, (const Pair&, const Pair&));
        FUN (bool, std::operator>,  (const Pair&, const Pair&));
        FUN (bool, std::operator>=, (const Pair&, const Pair&));

        // 20.2.2, p5
        std::pair<Y, Y> p0;

        Y::n_total_op_lt_ = 0;

        bool b = p0 == p0;
        rw_assert (b, 0, __LINE__,
                   "operator== (const pair<UserClass, UserClass>&, "
                   "const pair<UserClass, UserClass>&)");
        rw_assert (2 == Y::n_total_op_eq_, 0, __LINE__,
                   "operator== (const pair<UserClass, UserClass>&, "
                   "const pair<UserClass, UserClass>&)");


        // exercise lwg issue 348
        // (std::less required to be used in order to satisfy 20.3.3, p8)
        std::pair<Y, Y> p1;

        p0.first.data_.val_  = 1;
        p0.second.data_.val_ = 2;

        p1.first.data_.val_  = 3;
        p1.second.data_.val_ = 4;

        less_used = 0;

        b = p0 < p1;

        rw_assert (b, 0, __LINE__,
                   "operator< (const pair<Y, Y>&, const pair<Y, Y>&)");

        rw_assert (1 == less_used, 0, __LINE__,
                   "less<Y>::operator() called %d time(s), expected 1",
                   less_used);

        p1.first.data_.val_ = 1;

        less_used = 0;

        b = p0 < p1;

        rw_assert (b, 0, __LINE__,
                   "operator< (const pair<Y, Y>&, const pair<Y, Y>&)");

        rw_assert (3 == less_used, 0, __LINE__,
                   "less<Y>::operator() called %d time(s), expected 3",
                   less_used);

        p1.first.data_.val_ = 0;

        less_used = 0;

        b = p0 < p1;

        rw_assert (!b, 0, __LINE__,
                   "operator< (const pair<Y, Y>&, const pair<Y, Y>&)");

        rw_assert (2 == less_used, 0, __LINE__,
                   "less<Y>::operator() called %d time(s), expected 2",
                   less_used);
    }
}

/**************************************************************************/

static int
run_test (int, char**)
{
    test_pair (char (), "char", long (), "long");
    test_pair (int (), "int", float (), "float");

    return 0;
}

/**************************************************************************/

int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.pairs",
                    0 /* no comment */,
                    run_test,
                    "",
                    (void*)0 /* sentinel */);
}