/***************************************************************************
 *
 * 25.replace.cpp - test exercising 25.2.4 [lib.alg.replace]
 *
 * $Id: 25.replace.cpp 510970 2007-02-23 14:57:45Z faridz $
 *
 ***************************************************************************
 *
 * 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 1994-2006 Rogue Wave Software.
 * 
 **************************************************************************/

#include <algorithm>     // for replace(), replace_copy()
#include <cstring>       // for size_t, strlen()

#include <alg_test.h>
#include <rw_value.h>   // for UserClass
#include <driver.h>      // for rw_test()

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

_RWSTD_NAMESPACE (std) { 

// disable explicit instantiation for compilers (like MSVC)
// that can't handle it
#ifndef _RWSTD_NO_EXPLICIT_INSTANTIATION

template
void replace (FwdIter<eq_comp<assign<base<> > > >, 
              FwdIter<eq_comp<assign<base<> > > >,
              const eq_comp<assign<base<> > >&,
              const eq_comp<assign<base<> > >&);

template
void replace_if (FwdIter<assign<base<> > > , 
                 FwdIter<assign<base<> > > ,
                 predicate<assign<base<> > > ,
                 const assign<base<> > &);

template
OutputIter<eq_comp<assign<base<> > > >
replace_copy (InputIter<eq_comp<assign<base<> > > >, 
              InputIter<eq_comp<assign<base<> > > >,
              OutputIter<eq_comp<assign<base<> > > >, 
              const eq_comp<assign<base<> > >&,
              const eq_comp<assign<base<> > >&);

template
OutputIter<assign<base<> > >
replace_copy_if (InputIter<assign<base<> > > , 
                 InputIter<assign<base<> > > ,
                 OutputIter<assign<base<> > > , 
                 predicate<assign<base<> > > ,
                 const assign<base<> > &);

#endif // _RWSTD_NO_EXPLICIT_INSTANTIATION

}   // namespace std

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

// names of tested functions
const char* const fnames[] = { "replace", "replace_copy" };
const char* const fnames_if[] = { "replace_if", "replace_copy_if" };

// tags to select replace or replace_copy at compile time
struct ReplaceTag {
    enum { fname_inx = 0 };
    int use_predicate;
};

struct ReplaceCopyTag {
    enum { fname_inx = 1 };
    int use_predicate;
};

// used as a dummy template argument to test functions exercising replace()
// and replace_if() (to differentiate from replace_copy() and replace_copy_if())
struct NoIterator { };
const char* type_name (NoIterator, const UserClass*)
{
    return 0;
}

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

// predicate used as an argument to replace_if() and replace_copy_if()
template <class T>
struct EqualityPredicate
{
    static std::size_t funcalls_;

    EqualityPredicate (const T &val, int /* dummy */)
        : val_ (val) {
        funcalls_ = 0;
    }

    class ConvertibleToBool {
        bool result_;
    public:
        ConvertibleToBool (bool res): result_ (res) { /* empty */ }
        operator bool() const { return result_; }
    };

    // return a type other than bool but one that is implicitly
    // convertible to bool to detect incorrect assumptions
    ConvertibleToBool operator() (const T &arg) {
        ++funcalls_;
        return ConvertibleToBool (arg == val_);
    }

private:
    void operator= (EqualityPredicate&);
    const T &val_;
};

template <class T>
std::size_t EqualityPredicate<T>::funcalls_;

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

// exercises std::replace() and std::replace_if()
template <class Iterator, class T, class Predicate>
void test_replace (int line,
                   const char *src,       // source sequence
                   char        val,       // value to replace
                   char        new_val,   // value to replace it with
                   Iterator    dummy,     // not used
                   NoIterator,
                   const T*,
                   const Predicate*,
                   ReplaceTag  tag)       // replace() or replace_if()
{
    static const char* const itname = type_name (Iterator (), (T*)0);
    static const char* const fname = tag.use_predicate ? 
        fnames_if [tag.fname_inx] : fnames [tag.fname_inx];

    // compute the length of the source sequence
    const std::size_t nsrc = std::strlen (src);

    // construct a sequence of `nsrc' elements to pass to replace
    // (make sure there's always at least 1 element, even if the
    // sequence is otherwise empty, to avoid undefined behavior
    // when de-referencing xsrc[0] in inactive diagnostic messages)
    T* const xsrc     = T::from_char (src, nsrc + 1);
    T* const xsrc_end = xsrc + nsrc;

    // construct an element to replace
    T to_replace;
    to_replace.data_.val_ = val;

    // construct an element to replace it with
    T replace_with;
    replace_with.data_.val_ = new_val;

    // construct a predicate object (used with replace_if() only)
    const Predicate pred (to_replace, 0);

    // construct iterators pointing to the beginning and end
    // of the source sequence
    const Iterator first = make_iter (xsrc,     xsrc,     xsrc_end, dummy);
    const Iterator last  = make_iter (xsrc_end, xsrc_end, xsrc_end, dummy);

    // zero out predicate counters
    T::n_total_op_eq_ = 0;

    // call replace() or replace_if()
    if (tag.use_predicate)
        std::replace_if (first, last, pred, replace_with);
    else
        std::replace (first, last, to_replace, replace_with);

    // verify that the value to be replaced has been replaced
    // with the replacement value
    bool success = true;
    std::size_t i = 0;
    for ( ; i != nsrc; ++i) {
        success = to_replace.data_.val_ != xsrc [i].data_.val_;
        if (!success)
            break;
    }

    rw_assert (success, 0, line, 
               "line %d: %s<%s>(\"%s\", ..., %#c, %#c) ==> "
               "\"%{X=*.*}\"; unexpected element value %#c",
               __LINE__, fname, itname, src, val, new_val,
               int (nsrc), int (i), xsrc, src [i]);

    // check the id (not just the value) of the matching element
    // to make sure it has really been replaced
    for (i = 0; i != nsrc; ++i) {

        success =
               val != src [i]
            || val == src [i]
            && replace_with.origin_ == xsrc [i].origin_;

        if (!success)
            break;
    }

    rw_assert (success, 0, line,
               "line %d: %s<%s>(\"%s\", ..., %#c, %#c) ==> "
               "\"%{X=#*.*}\"; failed to replace element %zu: "
               "origin %d (%d, %d), expected %d (%d)",
               __LINE__, fname, itname, src, val, new_val,
               int (nsrc), int (i), xsrc,
               i, xsrc [i].origin_, xsrc [i].id_, xsrc [i].src_id_,
               replace_with.origin_, replace_with.id_);

    // verify the number of applications of the predicate: p 25.2.4.3
    if (tag.use_predicate) {
        rw_assert (pred.funcalls_ == nsrc, 0, line,
                   "line %d: %s<%s>(\"%s\", ..., %#c) called  "
                   "Predicate::operator() %zu times, %zu expected",
                   __LINE__, fname, itname, src, val,
                   pred.funcalls_, nsrc);
    }
    else {
        rw_assert (T::n_total_op_eq_ == nsrc, 0, line,
                   "line %d: %s<%s>(\"%s\", ..., %#c) called "
                   "T::operator< %zu times, %zu expected",
                   __LINE__, fname, itname, src, val,
                   T::n_total_op_eq_, nsrc);
    }

    delete[] xsrc;
}

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

// exercises std::replace_copy()
template <class Iterator, class OutputIterator, class T, class Predicate>
void test_replace (int line,
                   const char    *src,       // source sequence
                   char           val,       // value to replace
                   char           new_val,   // value to replace it with
                   Iterator       it,
                   OutputIterator dummy,
                   const T*,
                   const Predicate*,
                   ReplaceCopyTag tag)       // replace_copy or replace_copy_if
{
    static const char* const itname = type_name (it, (T*)0);
    static const char* const fname = tag.use_predicate ? 
        fnames_if [tag.fname_inx] : fnames [tag.fname_inx];

    const std::size_t nsrc = std::strlen (src);

    // construct a sequence of `nsrc' elements to pass to replace
    // (make sure there's always at least 1 element, even if the
    // sequence is otherwise empty, to avoid undefined behavior
    // when de-referencing xsrc[0] in inactive diagnostic messages)
    T* const xsrc = T::from_char (src, nsrc + 1);
    T* const xdst = T::from_char (src, nsrc + 1);

    T* const xsrc_end = xsrc + nsrc;
    T* const xdst_end = xdst + nsrc;

    T to_replace;
    to_replace.data_.val_ = val;

    T replace_with;
    replace_with.data_.val_ = new_val;

    const Predicate pred (to_replace, 0);

    const Iterator first = make_iter (xsrc,     xsrc,     xsrc_end, it);
    const Iterator last  = make_iter (xsrc_end, xsrc_end, xsrc_end, it);

    const OutputIterator result = make_iter (xdst, xdst, xdst_end, dummy);

    // zero out predicate counters
    T::n_total_op_eq_ = 0;

    const OutputIterator end = tag.use_predicate
        ? std::replace_copy_if (first, last, result, pred, replace_with)
        : std::replace_copy (first, last, result, to_replace, replace_with);

    // verify that the returned iterator is set as expected
    rw_assert (end.cur_ == result.cur_ + nsrc, 0, line,
               "line %d: %s<%s>(\"%s\", ..., %#c) == result + %zu, got %td",
               __LINE__, fname, itname, src, val, nsrc, end.cur_ - xdst);

    // verify that the value to be replaced does not appear anywhere
    // in the range [result, end)
    bool success = true;
    std::size_t i = 0;
    for ( ; i != nsrc; ++i) {
        typedef unsigned char UChar;
        success = UChar (val) != xdst [i].data_.val_;
        if (!success)
            break;
    }

    rw_assert (success, 0, line,
               "line %d: %s<%s>(\"%s\", ..., %#c) ==> "
               "\"%{X=*.*}\"; unexpected element value %#c",
               __LINE__, fname, itname, src, val,
               int (nsrc), int (i), xdst, src [i]);

    // check the id (not just the value) of the matching element
    // to make sure it has really been copied
    for (i = 0; i != nsrc; ++i) {
        success =
               val != src [i]
            || val == src [i]
            && replace_with.origin_ == xdst [i].origin_;

        if (!success)
            break;
    }

    rw_assert (success, 0, line,
               "line %d: %s<%s>(\"%s\", ..., %#c, %#c) ==> "
               "\"%{X=*.*}\"; failed to copy and replace element %zu: "
               "origin %d (%d, %d), expected %d (%d)",
               __LINE__, fname, itname, src, val, new_val,
               int (nsrc), int (i), xdst,
               i, xdst [i].origin_, xdst [i].id_, xdst [i].src_id_,
               replace_with.origin_, replace_with.id_);

    // verify the number of applications of the predicate: p 25.2.4.7
    if (tag.use_predicate) {
        rw_assert (pred.funcalls_ == nsrc, 0, line,
                   "line %d: %s<%s>(\"%s\", ..., %#c) called  "
                   "Predicate::operator() %zu times, %zu expected",
                   __LINE__, fname, itname, src, val,
                   pred.funcalls_, nsrc);
    }
    else {
        rw_assert (T::n_total_op_eq_ == nsrc, 0, line,
                   "line %d: %s<%s>(\"%s\", ..., %#c) called "
                   "T::operator< %zu times, %zu expected",
                   __LINE__, fname, itname, src, val,
                   T::n_total_op_eq_, nsrc);
    }

    delete[] xsrc;
    delete[] xdst;
}

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

// exercises all four function templates
template <class Iterator1, class Iterator2, class T, 
          class Predicate, class Tag>
void test_replace (Iterator1 it1, Iterator2 it2, const T*, 
                   const Predicate* pred, Tag tag)
{
    static const char* const it1name = type_name (it1, (T*)0);
    static const char* const it2name = type_name (it2, (T*)0);

    if (tag.fname_inx) {  // replace_copy(), replace_copy_if()
         rw_info (0, 0, 0,
                  "std::%s (%s, %s, %s, %s, const T&)",
                  tag.use_predicate ? "replace_copy_if" : "replace_copy",
                  it1name, it1name, it2name,
                  tag.use_predicate ? "UnaryPredicate" : "const T&");
    }
    else {   // replace, replace_if()
         rw_info (0, 0, 0,
                  "std::%s (%s, %s, %s, const T&)",
                  tag.use_predicate ? "replace_if" : "replace",
                  it1name, it1name,
                  tag.use_predicate ? "UnaryPredicate" : "const T&");
    }


#define TEST(src, val, new_val) \
    test_replace (__LINE__, src, val, new_val, it1, it2, (T*)0, pred, tag)

    //    +----------------------- original sequence
    //    |               +------- value to replace
    //    |               |     +- value to replace it with
    //    |               |     |
    //    v               v     v
    TEST ("",            'a',  'b');
    TEST ("a",           'a',  'b');
    TEST ("aa",          'a',  'b');
    TEST ("aaa",         'a',  'b');
    TEST ("aaaa",        'a',  'b');
    TEST ("aaaaa",       'a',  'b');
    TEST ("aaaaaa",      'a',  'b');
    TEST ("aaaaaaa",     'a',  'b');
    TEST ("aaaaaaaa",    'a',  'b');
    TEST ("aaaaaaaaa",   'a',  'b');
    TEST ("aaaaaaaaaa",  'a',  'b');

    TEST ("b",           'a',  'b');
    TEST ("bb",          'a',  'b');
    TEST ("ba",          'a',  'b');
    TEST ("ab",          'a',  'b');
    TEST ("abc",         'a',  'b');
    TEST ("bac",         'a',  'b');
    TEST ("bca",         'a',  'b');
    TEST ("aba",         'a',  'b');
    TEST ("abab",        'a',  'b');
    TEST ("ababa",       'a',  'b');
    TEST ("bababa",      'a',  'b');
    TEST ("bababab",     'a',  'b');
    TEST ("babababa",    'a',  'b');
    TEST ("bbbbbbbbb",   'a',  'b');
}

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

/* extern */ int rw_opt_no_replace;            // --no-replace
/* extern */ int rw_opt_no_replace_if;         // --no-replace_if
/* extern */ int rw_opt_no_replace_copy;       // --no-replace_copy
/* extern */ int rw_opt_no_replace_copy_if;    // --no-replace_copy_if
/* extern */ int rw_opt_no_input_iter;         // --no-InputIterator
/* extern */ int rw_opt_no_output_iter;        // --no-OutputIterator
/* extern */ int rw_opt_no_fwd_iter;           // --no-ForwardIterator
/* extern */ int rw_opt_no_bidir_iter;         // --no-BidirectionalIterator
/* extern */ int rw_opt_no_rnd_iter;           // --no-RandomAccessIterator

template <class T, class Predicate, class Tag> 
void test_replace (const T* , const Predicate* pred, Tag tag)
{
    rw_info (0, 0, 0,  
            "template <class ForwardIterator, class T> "
            "std::%s (ForwardIterator, ForwardIterator, "
            "%s, const T&)", 
            tag.use_predicate ? "replace_if" : "replace",
            tag.use_predicate ? "Predicate" : "const T&");

    if (rw_opt_no_fwd_iter) {
        rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
    }
    else {
        test_replace (FwdIter<T>(), NoIterator (), (T*)0, pred, tag);
    }

    if (rw_opt_no_bidir_iter) {
        rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
    }
    else {
        test_replace (BidirIter<T>(), NoIterator (), (T*)0, pred, tag);
    }

    if (rw_opt_no_rnd_iter) {
        rw_note (0, __FILE__, __LINE__,  "RandomAccessIterator test disabled");
    }
    else {
        test_replace (RandomAccessIter<T>(), NoIterator (), (T*)0, pred, tag);
    }
}

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

template <class T>
void test_replace (const T* )
{
    const ReplaceTag replace_tag    = { false };
    const ReplaceTag replace_if_tag = { true };

    if (rw_opt_no_replace) {
        rw_note (0, __FILE__, __LINE__,  "std::replace test disabled");
    }
    else {
        const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*) 0;
        test_replace((T*)0, pred, replace_tag);
    }

    if (rw_opt_no_replace_if) {
        rw_note (0, __FILE__, __LINE__,  "std::replace_if test disabled");
    }
    else {
        const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*) 1;
        test_replace((T*)0, pred, replace_if_tag);
    }
}

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

template <class InputIterator, class T, class Predicate, class Tag> 
void test_replace_copy (const InputIterator& iter, const T*, 
                        const Predicate* pred, Tag tag)
{
    if (rw_opt_no_output_iter) {
        rw_note (0, __FILE__, __LINE__, "OutputIterator test disabled");
    }
    else {
        test_replace (iter, OutputIter<T>(0, 0, 0), (T*)0, pred, tag);
    }

    if (rw_opt_no_fwd_iter) {
        rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
    }
    else {
        test_replace (iter, FwdIter<T>(), (T*)0, pred, tag);
    }

    if (rw_opt_no_bidir_iter) {
        rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
    }
    else {
        test_replace (iter, BidirIter<T>(), (T*)0, pred, tag);
    }

    if (rw_opt_no_rnd_iter) {
        rw_note (0, __FILE__, __LINE__,  "RandomAccessIterator test disabled");
    }
    else {
        test_replace (iter, RandomAccessIter<T>(), (T*)0, pred, tag);
    }
}

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

template <class T, class Predicate, class Tag> 
void test_replace_copy (const T*, const Predicate* pred, Tag tag)
{
    rw_info (0, 0, 0, 
             "template "
             "<class InputIterator, class OutputIterator, class T> "
             "std::%s (InputIterator, InputIterator, "
             "OutputIterator, %s, const T&)",
             tag.use_predicate ? "replace_copy_if" : "replace_copy",
             tag.use_predicate ? "Predicate" : "const T&");

    if (rw_opt_no_input_iter) {
        rw_note (0, __FILE__, __LINE__, "InputIterator test disabled");
    }
    else {
        test_replace_copy (InputIter<T>(0, 0, 0), (T*)0, pred, tag);
    }

    if (rw_opt_no_fwd_iter) {
        rw_note (0, __FILE__, __LINE__, "ForwardIterator test disabled");
    }
    else {
        test_replace_copy (FwdIter<T>(), (T*)0, pred, tag);
    }

    if (rw_opt_no_bidir_iter) {
        rw_note (0, __FILE__, __LINE__, "BidirectionalIterator test disabled");
    }
    else {
        test_replace_copy (BidirIter<T>(), (T*)0, pred, tag);
    }

    if (rw_opt_no_rnd_iter) {
        rw_note (0, __FILE__, __LINE__,  "RandomAccessIterator test disabled");
    }
    else {
        test_replace_copy (RandomAccessIter<T>(), (T*)0, pred, tag);
    }
}

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

template <class T>
void test_replace_copy (const T* )
{
    const ReplaceCopyTag replace_copy_tag    = { false };
    const ReplaceCopyTag replace_copy_if_tag = { true };

    if (rw_opt_no_replace_copy) {
        rw_note (0, __FILE__, __LINE__, "std::replace_copy test disabled");
    }
    else {
        const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*) 0;
        test_replace_copy ((T*)0, pred, replace_copy_tag);
    }

    if (rw_opt_no_replace_copy_if) {
        rw_note (0, __FILE__, __LINE__, "std::replace_copy_if test disabled");
    }
    else {
        const EqualityPredicate<T>* const pred = (EqualityPredicate<T>*)1;
        test_replace_copy ((T*)0, pred, replace_copy_if_tag);
    }
}

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

static int
run_test (int, char*[])
{
    test_replace ((UserClass*)0);

    test_replace_copy ((UserClass*)0);

    return 0;
}

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

int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.alg.replace",
                    0 /* no comment */,
                    run_test,
                    "|-no-replace# "
                    "|-no-replace_if# "
                    "|-no-replace_copy# "
                    "|-no-replace_copy_if# "
                    "|-no-InputIterator# "
                    "|-no-OutputIterator# "
                    "|-no-ForwardIterator# "
                    "|-no-BidirectionalIterator# "
                    "|-no-RandomAccessIterator#",                    
                    &rw_opt_no_replace,
                    &rw_opt_no_replace_if,
                    &rw_opt_no_replace_copy,
                    &rw_opt_no_replace_copy_if,
                    &rw_opt_no_input_iter,
                    &rw_opt_no_output_iter,
                    &rw_opt_no_fwd_iter,
                    &rw_opt_no_bidir_iter,
                    &rw_opt_no_rnd_iter);
}