/***************************************************************************
 *
 * specialized.cpp - test exercising 20.4.4 [lib.specialized.algorithms]
 *
 * $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 <memory>

#include <rw_alg_test.h>
#include <rw_driver.h>

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

#ifndef _RWSTD_NO_EXCEPTIONS

struct Y
{
    static int count_;
    static int ctor_;
    static int dtor_;
    static int throw_at_;

    int val_;

    Y (const Y &rhs) : val_ (rhs.val_) {
        ++ctor_;
        if (count_ + 1 == throw_at_)
            throw 0;
        ++count_;
    }

    Y (int val) : val_ (val) {
        ++ctor_;
        if (count_ + 1 == throw_at_)
            throw 0;
        ++count_;
    }

    ~Y () {
        ++dtor_;
        val_ = -2;
        --count_;
    }

private:
    void operator= (const Y&);   // not Assignable
};


int Y::count_;
int Y::ctor_;
int Y::dtor_;
int Y::throw_at_;

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

template <class T>
const char* type_name (volatile T*, T*) { return "volatile T*"; }

template <class T>
const char* type_name (const volatile T*, T*) { return "const volatile T*"; }

// defined as ordinary functions (as opposed to templates)
// to avoid tripping up broken compilers on argument deduction
inline const volatile int*
make_iter (const int *beg, const int*, const int*, const volatile int*)
{
    return beg;
}

inline volatile Y*
make_iter (Y *beg, Y*, Y*, volatile Y*)
{
    return beg;
}

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

// exercises uninitialized_copy [lib.uninitialized.copy]
// with emphasis on exception safety - the function is to have no effect
// if an exception is thrown
template <class InputIterator, class ForwardIterator>
void test_uninitialized_copy (const InputIterator &dummy,
                              const ForwardIterator*)
{
    const char* const i1name = type_name (dummy, (int*)0);
    const char* const i2name = type_name (ForwardIterator (), (Y*)0);

    rw_info (0, 0, __LINE__, "std::uninitialized_copy(%s, %1$s, %s)",
             i1name, i2name);

    static const int a[] = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
    };

    const unsigned N = sizeof a / sizeof *a;

    // allocate an uninitialized buffer
    Y *buf = _RWSTD_STATIC_CAST (Y*, ::operator new (N * sizeof (Y)));

    for (unsigned i = 0; i != N; ++i) {

        Y::count_ = Y::ctor_ = Y::dtor_ = 0;

        // throw during the copy construction of the i-th elem
        Y::throw_at_ = i;

        try {
            // constructs i elements, the last ctor throws
            const InputIterator first =
                make_iter (a, a, a + i, dummy);
            const InputIterator last =
                make_iter (a + i, a, a + i, first);

            const ForwardIterator result =
                make_iter (buf, buf, buf + i, ForwardIterator ());

            std::uninitialized_copy (first, last, result);

            rw_assert (i == 0, 0, __LINE__,
                       "%zu. expected exception not thrown", i);
        }
        catch (int) {
            // ctor throws an int, this is what's expected
        }
        catch (...) {
            rw_assert (0, 0, __LINE__,
                       "%zu. exception of an unexpected type thrown", i);
        }

        // verify that all constructed elements were destroyed
        rw_assert (Y::count_ == 0, 0, __LINE__,
                   "%zu. %d elements not destroyed", i, Y::count_);

        // verify that the expected number of ctor and dtor calls were made
        rw_assert (Y::ctor_ == Y::throw_at_, 0, __LINE__,
                   "%zu. %d ctor calls expected, got %d",
                   i, Y::throw_at_, Y::ctor_);
        rw_assert (i ? Y::dtor_ + 1 == Y::throw_at_ : true, 0, __LINE__,
                   "%zu. %d dtor calls expected, got %d",
                   i, Y::throw_at_ - 1, Y::dtor_);
    }

    ::operator delete (buf);
}

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

// exercises 20.4.4.2 and 3 - uninitialized_fill [lib.uninitialized.fill]
// and uninitialized_fill_n [lib.uninitialized.fill_n] with emphasis on
// exception safety - the function is to have no effect if an exception
// is thrown
template <class ForwardIterator>
void test_uninitialized_fill (const ForwardIterator*, bool test_count)
{
    const char* const itname = type_name (ForwardIterator (), (Y*)0);

    rw_info (0, 0, __LINE__,
             "std::uninitialized_fill%{?}_n%{;}(%s, %{?}size_t%{:}%2$s%{;}, "
             "const int&)", test_count, itname, test_count);

    const unsigned N = 32;

    // allocate an uninitialized buffer
    Y *buf = _RWSTD_STATIC_CAST (Y*, ::operator new (N * sizeof (Y)));

    for (unsigned i = 0; i != N; ++i) {

        // prevent ctor below from throwing
        Y::throw_at_ = -1;

        // create a temporary and reset counters (in that order)
        Y val (i);

        Y::count_ = Y::ctor_ = Y::dtor_ = 0;

        // throw during the copy construction of the i-th elem
        Y::throw_at_ = i;

        try {
            // copy-constructs i elements, the last copy ctor throws
            const ForwardIterator first =
                make_iter (buf, buf, buf + i, ForwardIterator ());

            if (test_count) {
                std::uninitialized_fill_n (first, i, val);
            }
            else {
                const ForwardIterator last =
                    make_iter (buf + i, buf, buf + i, first);

                std::uninitialized_fill (first, last, val);
            }
                
            rw_assert (i == 0, 0, __LINE__,
                       "%zu. expected exception not thrown", i);
        }
        catch (int) {
            // ctor throws an int, this is what's expected
        }
        catch (...) {
            rw_assert (0, 0, __LINE__,
                       "%zu. exception of an unexpected type thrown", i);
        }

        // verify that all constructed elements were destroyed
        rw_assert (Y::count_ == 0, 0, __LINE__,
                   "%zu. %d elements not destroyed", i, Y::count_);

        // verify that the expected number of ctor and dtor calls were made
        rw_assert (Y::ctor_ == Y::throw_at_, 0, __LINE__,
                   "%zu. %d ctor calls expected, got %d",
                   i, Y::throw_at_, Y::ctor_);
        rw_assert (i ? Y::dtor_ + 1 == Y::throw_at_ : true, 0, __LINE__,
                   "%d. %d dtor calls expected, got %d",
                   i, Y::throw_at_ - 1, Y::dtor_);
    }

    ::operator delete (buf);
}

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

int opt_copy;
int opt_fill;
int opt_fill_n;

int opt_input_iter;
int opt_fwd_iter;
int opt_bidir_iter;
int opt_rnd_iter;
int opt_volatile_ptr;


template <class InputIterator>
void test_uninitialized_copy (const InputIterator &dummy)
{
    if (-1 < opt_fwd_iter)
        test_uninitialized_copy (dummy, (FwdIter<Y>*)0);
    else
        rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
                 "ForwardIterator tests disabled");

    if (-1 < opt_bidir_iter)
        test_uninitialized_copy (dummy, (BidirIter<Y>*)0);
    else
        rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
                 "BidirectionalIterator tests disabled");

    if (-1 < opt_rnd_iter)
        test_uninitialized_copy (dummy, (RandomAccessIter<Y>*)0);
    else
        rw_note (-1 > opt_rnd_iter--, 0, __LINE__,
                 "RandomAccessIterator tests disabled");

    if (-1 < opt_volatile_ptr) {
        typedef volatile Y* VolatilePointer;
        test_uninitialized_copy (dummy, (VolatilePointer*)0);
    }
    else
        rw_note (-1 > opt_volatile_ptr--, 0, __LINE__,
                 "volatile T* tests disabled");
}

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

static int
run_test (int, char**)
{
    typedef const volatile int* ConstVolatilePointer;
    typedef /* */ volatile Y*   VolatilePointer;

    if (-1 < opt_copy) {
        if (-1 < opt_input_iter)
            test_uninitialized_copy (InputIter<int>(0, 0, 0));
        else
            rw_note (-1 > opt_input_iter--, 0, __LINE__,
                     "InputIterator tests disabled");

        if (-1 < opt_fwd_iter)
            test_uninitialized_copy (ConstFwdIter<int>());
        else
            rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
                     "ForwardIterator tests disabled");
    
        if (-1 < opt_bidir_iter)
            test_uninitialized_copy (ConstBidirIter<int>());
        else
            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
                     "BidirectionalIterator tests disabled");

        if (-1 < opt_rnd_iter)
            test_uninitialized_copy (ConstRandomAccessIter<int>());
        else
            rw_note (-1 > opt_rnd_iter--, 0, __LINE__,
                     "RandomAccessIterator tests disabled");

        if (-1 < opt_volatile_ptr)
            test_uninitialized_copy (ConstVolatilePointer ());
        else
            rw_note (-1 > opt_volatile_ptr--, 0, __LINE__,
                     "volatile T* tests disabled");
    }
    else
        rw_note (0, 0, 0, "tests of std::uninitialized_copy disabled");

    //////////////////////////////////////////////////////////////////

    if (-1 < opt_fill) {
        if (-1 < opt_fwd_iter)
            test_uninitialized_fill ((FwdIter<Y>*)0, false);
        else
            rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
                     "ForwardIterator tests disabled");

        if (-1 < opt_bidir_iter)
            test_uninitialized_fill ((BidirIter<Y>*)0, false);
        else
            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
                     "BidirectionalIterator tests disabled");

        if (-1 < opt_bidir_iter)
            test_uninitialized_fill ((RandomAccessIter<Y>*)0, false);
        else
            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
                     "RandomAccessIterator tests disabled");

        if (-1 < opt_volatile_ptr) {
            test_uninitialized_fill ((VolatilePointer*)0, false);
        }
        else
            rw_note (-1 > opt_volatile_ptr++,
                     0, 0, "volatile T* tests disabled");
    }
    else
        rw_note (0, 0, 0, "tests of std::uninitialized_fill disabled");

    //////////////////////////////////////////////////////////////////
    if (-1 < opt_fill) {
        if (-1 < opt_fwd_iter)
            test_uninitialized_fill ((FwdIter<Y>*)0, true);
        else
            rw_note (-1 > opt_fwd_iter--, 0, __LINE__,
                     "ForwardIterator tests disabled");

        if (-1 < opt_bidir_iter)
            test_uninitialized_fill ((BidirIter<Y>*)0, true);
        else
            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
                     "BidirectionalIterator tests disabled");

        if (-1 < opt_bidir_iter)
            test_uninitialized_fill ((RandomAccessIter<Y>*)0, true);
        else
            rw_note (-1 > opt_bidir_iter--, 0, __LINE__,
                     "RandomAccessIterator tests disabled");

        if (-1 < opt_volatile_ptr) {
            test_uninitialized_fill ((VolatilePointer*)0, true);
        }
        else
            rw_note (-1 > opt_volatile_ptr--, 0, __LINE__,
                     "volatile T* tests disabled");
    }
    else
        rw_note (0, 0, 0, "tests of std::uninitialized_fill disabled");

    return 0;
}

#else   // _RWSTD_NO_EXCEPTIONS

static int
run_test (int, char**)
{
    rw_note (0, 0, 0,
             "exceptions disabled (_RWSTD_NO_EXCEPTIONS #defined), "
             "cannot test");

    return 0;
}

#endif   // _RWSTD_NO_EXCEPTIONS

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

int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.specialized.algorithms",
                    0 /* no comment */,
                    run_test,
                    "|-uninitialized_copy~ "
                    "|-uninitialized_fill~ "
                    "|-uninitialized_fill_n~ "
                    "|-InputIterator~ "
                    "|-ForwardIterator~ "
                    "|-BidirectionalIterator~ "
                    "|-RandomAccessIterator~ "
                    "|-volatile-pointer",
                    &opt_copy,
                    &opt_fill,
                    &opt_fill_n,
                    &opt_input_iter,
                    &opt_fwd_iter,
                    &opt_bidir_iter,
                    &opt_rnd_iter,
                    &opt_volatile_ptr);
}