/***************************************************************************
 *
 * 21.string.copy.cpp - string test exercising [lib.string::copy]
 *
 * $Id$ 
 *
 ***************************************************************************
 *
 * Copyright 2006 The Apache Software Foundation or its licensors,
 * as applicable.
 *
 * Copyright 2006 Rogue Wave Software.
 *
 * Licensed 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 <string>           // for string
#include <cstddef>          // size_t
#include <stdexcept>        // for out_of_range

#include <21.strings.h>     // for StringMembers
#include <driver.h>         // for rw_assert()
#include <rw_allocator.h>   // for UserAlloc
#include <rw_char.h>        // for rw_expand()

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

// for convenience and brevity
#define Copy(which)               StringIds::copy_ ## which

static const char* const exceptions[] = {
    "unknown exception", "out_of_range", "length_error",
    "bad_alloc", "exception"
};

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

// exercises:
// copy (value_type*, size_type)
static const StringTestCase
ptr_size_test_cases [] = {

#undef TEST
#define TEST(str, size, res) {                \
        __LINE__, -1, size, -1, -1, -1,       \
        str, sizeof str - 1, 0, 0,            \
        res, sizeof res - 1, 0                \
    }

    //    +--------------------------------------- controlled sequence
    //    |                       +--------------- copy() n argument
    //    |                       |   +----------- expected result sequence
    //    |                       |   |     
    //    V                       V   V             
    TEST ("ab",                   2,  "ab"),       

    TEST ("",                     0,  ""),         
    TEST ("",                    10,  ""),          

    TEST ("<U0>",                 1,  "<U0>"),       
    TEST ("<U0>@2",               2,  "<U0>@2"),    

    TEST ("abc",                  0,  ""), 
    TEST ("abc",                  1,  "a"),                 
    TEST ("abc",                  2,  "ab"),       
    TEST ("abc",                  3,  "abc"), 
    TEST ("abc",                  5,  "abc"),

    TEST ("a<U0>b<U0>@2c",       10,  "a<U0>b<U0>@2c"),  
    TEST ("<U0>ab<U0>@3c<U0>",    1,  "<U0>"),
    TEST ("<U0>ab<U0>@3c<U0>",    8,  "<U0>ab<U0>@3c<U0>"),
    TEST ("<U0>ab<U0>@3c<U0>",    5,  "<U0>ab<U0>@2"),   
    TEST ("<U0>@2ab<U0>@2c<U0>",  6,  "<U0>@2ab<U0>@2"), 

    TEST ("x@4096",            4096,  "x@4096"),

    TEST ("last",                 4,  "last")       
};

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

// exercises:
// copy (value_type*, size_type, size_type)
static const StringTestCase
ptr_size_size_test_cases [] = {

#undef TEST
#define TEST(str, size, off, res, bthrow)  {    \
        __LINE__, off, size, -1, -1, -1,        \
        str, sizeof str - 1, 0, 0,              \
        res, sizeof res - 1, bthrow             \
    }

    //    +------------------------------------------ controlled sequence
    //    |                       +------------------ copy() n argument
    //    |                       |   +-------------- copy() pos argument
    //    |                       |   |  +----------- expected result sequence
    //    |                       |   |  |       +--- exception info:
    //    |                       |   |  |       |      0 - no exception    
    //    |                       |   |  |       |      1 - out_of_range 
    //    |                       |   |  |       |   
    //    |                       |   |  |       +---------+   
    //    V                       V   V  V                 V  
    TEST ("ab",                   2,  0, "ab",             0),

    TEST ("",                     0,  0, "",               0),
    TEST ("",                    10,  0, "",               0),

    TEST ("<U0>",                 1,  0, "<U0>",           0),
    TEST ("<U0>@2",               1,  1, "<U0>",           0),
    TEST ("<U0>@2",               2,  0, "<U0>@2",         0),

    TEST ("abc",                  1,  0, "a",              0),
    TEST ("abc",                  1,  1, "b",              0),
    TEST ("abc",                  1,  2, "c",              0),

    TEST ("abc",                  0,  0, "",               0),
    TEST ("abc",                  2,  0, "ab",             0),
    TEST ("abc",                  2,  1, "bc",             0),
    TEST ("abc",                  3,  0, "abc",            0),
    TEST ("abc",                 10,  1, "bc",             0),
    TEST ("abc",                  3,  2, "c",              0),

    TEST ("a<U0>b<U0>@2c",       10,  1, "<U0>b<U0>@2c",   0),
    TEST ("a<U0>b<U0>@2c",       10,  0, "a<U0>b<U0>@2c",  0),
    TEST ("a<U0>b<U0>@2c",        1,  1, "<U0>",           0),

    TEST ("<U0>ab<U0>@3c<U0>",   10,  1, "ab<U0>@3c<U0>",  0),
    TEST ("<U0>ab<U0>@3c<U0>",    5,  0, "<U0>ab<U0>@2",   0),
    TEST ("<U0>ab<U0>@3c<U0>",    3,  3, "<U0>@3",         0),

    TEST ("<U0>@2ab<U0>@2c<U0>",  6,  0, "<U0>@2ab<U0>@2", 0),
    TEST ("<U0>@2ab<U0>@2c<U0>",  4,  1, "<U0>ab<U0>",     0),

    TEST ("x@4096",            4096,  0, "x@4096",         0),
    TEST ("x@4096",               2,  1, "xx",             0),
    TEST ("x@4096",            4096, 4095, "x",            0),

    TEST ("<U0>",                 0,  2, "",               1),
    TEST ("a",                    0, 10, "",               1),
    TEST ("x@4096",               0, 4106, "",             1),

    TEST ("last",                 4,  0, "last",           0)
};

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

template <class charT, class Traits, class Allocator>
void test_copy (charT, Traits*, Allocator*,                
                const StringFunc     &func,
                const StringTestCase &tcase)
{
    typedef std::basic_string <charT, Traits, Allocator> String;

    static const std::size_t BUFSIZE = 256;

    static charT wstr_buf [BUFSIZE];
    std::size_t str_len = sizeof wstr_buf / sizeof *wstr_buf;
    charT* wstr = rw_expand (wstr_buf, tcase.str, tcase.str_len, &str_len);

    static charT wres_buf [BUFSIZE];
    std::size_t res_len = sizeof wres_buf / sizeof *wres_buf;
    charT* wres = rw_expand (wres_buf, tcase.res, tcase.nres, &res_len);

    // construct the string object 
    const String  str (wstr, str_len);

    if (wstr != wstr_buf)
        delete[] wstr;

    wstr = 0;

    const std::size_t min_len =
        str_len < std::size_t (tcase.size) ? str_len : tcase.size;

    std::size_t res = 0;

    // create destination array and initialize it with garbage
    charT* const s_res = new charT [min_len + 2];

    const char cgb [2] = "#";
    const charT wcgb = make_char (cgb [0], (charT*)0);
    Traits::assign (s_res, min_len + 1, wcgb);
    s_res [min_len + 1] = charT ();

    // save the state of the string object before the call
    // to detect wxception safety violations (changes to
    // the state of the object after an exception)
    const StringState str_state (rw_get_string_state (str));

#ifndef _RWSTD_NO_EXCEPTIONS

    // is some exception expected?
    const char* const expected = tcase.bthrow ? exceptions [1] : 0;
    const char* caught = 0;

#else   // if defined (_RWSTD_NO_EXCEPTIONS)

    if (tcase.bthrow) {
        if (wres != wres_buf)
            delete[] wres;

        return;
    }

#endif   // _RWSTD_NO_EXCEPTIONS

    try {
        switch (func.which_) {
        case Copy (ptr_size): {
            res = str.copy (s_res, tcase.size);
            break;
        }

        case Copy (ptr_size_size): {
            res = str.copy (s_res, tcase.size, tcase.off);
            break;
        }
        default:
            RW_ASSERT (!"logic error: unknown copy overload");
            return;
        }

        // verify the returned value
        rw_assert (res == res_len, 0, tcase.line,
                   "line %d. %{$FUNCALL} == %zu, got %zu", 
                   __LINE__, res_len, res);

        if (res == res_len) 
        {
            const std::size_t match = rw_match (tcase.res, s_res, res_len);
            bool success = match == res_len;

            rw_assert (success, 0, tcase.line,
                       "line %d. %{$FUNCALL} expected %{#*s}, "
                       "got %{/*.*Gs}, differ at pos %zu",
                       __LINE__, int (tcase.nres), tcase.res, 
                       int (sizeof (charT)), int (res), s_res, match);

            success = 1 == rw_match (cgb, s_res + min_len, 1);
            rw_assert (success, 0, tcase.line,
                       "line %d. %{$FUNCALL} detected writing past the end of "
                       "the provided buffer", __LINE__);
        }
    }

#ifndef _RWSTD_NO_EXCEPTIONS

    catch (const std::out_of_range &ex) {
        caught = exceptions [1];
        rw_assert (caught == expected, 0, tcase.line,
                   "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
                   "unexpectedly%{;} caught std::%s(%#s)",
                   __LINE__, 0 != expected, expected, caught, ex.what ());
    }
    catch (const std::exception &ex) {
        caught = exceptions [4];
        rw_assert (0, 0, tcase.line,
                   "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
                   "unexpectedly%{;} caught std::%s(%#s)",
                   __LINE__, 0 != expected, expected, caught, ex.what ());
    }
    catch (...) {
        caught = exceptions [0];
        rw_assert (0, 0, tcase.line,
                   "line %d. %{$FUNCALL} %{?}expected %s,%{:}"
                   "unexpectedly%{;} caught %s",
                   __LINE__, 0 != expected, expected, caught);
    }

    if (caught) {
        // verify that an exception thrown during allocation
        // didn't cause a change in the state of the object
        str_state.assert_equal (rw_get_string_state (str),
                                __LINE__, tcase.line, caught);
    }
    else if (-1 != tcase.bthrow) {
        rw_assert (caught == expected, 0, tcase.line,
                   "line %d. %{$FUNCALL} %{?}expected %s, caught %s"
                   "%{:}unexpectedly caught %s%{;}",
                   __LINE__, 0 != expected, expected, caught, caught);
    }

#endif   // _RWSTD_NO_EXCEPTIONS

    if (wres != wres_buf)
        delete[] wres;

    delete[] s_res;
}

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

DEFINE_STRING_TEST_DISPATCH (test_copy);

int main (int argc, char** argv)
{
    static const StringTest
    tests [] = {

#undef TEST
#define TEST(which) {                                               \
        Copy (which), which ## _test_cases,                         \
        sizeof which ## _test_cases / sizeof *which ## _test_cases  \
    }

        TEST (ptr_size),
        TEST (ptr_size_size)
    };

    const std::size_t test_count = sizeof tests / sizeof *tests;

    return rw_run_string_test (argc, argv, __FILE__,
                               "lib.string.copy",
                               test_copy, tests, test_count);
}