//-----------------------------------------------------------------------------

 // boost-libs variant/test/test2.cpp header file

 // See http://www.boost.org for updates, documentation, and revision history.

 //-----------------------------------------------------------------------------

 //

 // Copyright (c) 2003

 // Eric Friedman, Itay Maman

 //

 // Distributed under the Boost Software License, Version 1.0. (See

 // accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 /*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 */

 #include "boost/config.hpp"

 #include "boost/test/minimal.hpp"

 #include "boost/variant.hpp"

 #include "jobs.h"

 #include <cassert>

 #include <iostream>

 #include <algorithm>

 #include <cstring>

 #ifdef __SYMBIAN32__

 #include "std_log_result.h"

 #define LOG_FILENAME_LINE __FILE__, __LINE__

 #endif

 using boost::apply_visitor;

 struct short_string

 {

    BOOST_STATIC_CONSTANT(size_t, e_limit = 101);

    short_string() : len_(0) 

    { 

       buffer_[0] = '\0';

    }

    short_string(const char* src) 

    {

 #ifndef BOOST_NO_STDC_NAMESPACE

       using std::strlen;

 #endif // BOOST_NO_STDC_NAMESPACE

       size_t e_limit = this->e_limit; // avoid warnings on some compilers

       size_t src_len = strlen(src);

       len_ = (std::min)(src_len, e_limit-1);

       std::copy(src, src + len_, buffer_);

       buffer_[len_] = '\0';

    }

    short_string(const short_string& other) : len_(other.len_)

    {

       std::copy(other.buffer_, other.buffer_ + e_limit, buffer_);

    }

    void swap(short_string& other)

    {

       char temp[e_limit];

       std::copy(buffer_, buffer_ + e_limit, temp);

       std::copy(other.buffer_, other.buffer_ + e_limit, buffer_);

       std::copy(temp, temp + e_limit, other.buffer_);

       std::swap(len_, other.len_);

    }

    short_string& operator=(const short_string& rhs)

    {

       short_string temp(rhs);

       swap(temp);

       return *this;

    }

    operator const char*() const

    {

       return buffer_;

    }

 private:

    char buffer_[e_limit];

    size_t len_;

 }; //short_string

 std::ostream& operator<<(std::ostream& out, const short_string& s)

 {

    out << static_cast<const char*>(s);

    return out;

 }

 void run()

 {   

    using boost::variant;

    variant<short, short_string> v0;

    variant<char, const char*> v1;

    variant<short_string, char > v2;

    //

    // Default construction

    //

    verify(v0, spec<short>());

    verify(v1, spec<char>());

    verify(v2, spec<short_string>());

    //

    // Implicit conversion to bounded type

    //

    v1 = "I am v1";

    verify(v1, spec<const char*>(), "[V] I am v1");

    v2 = "I am v2";

    verify(v2, spec<short_string>(), "[V] I am v2");

    //

    // Variant-to-variant assignment

    //

    v0 = v1;

    verify(v0, spec<short_string>(), "[V] I am v1");

    v1 = v0;

    verify(v1, spec<const char*>(), "[V] I am v1");

    const int n0 = 88;

    v1 = n0;

    v0 = v1;

    //

    // Implicit conversion to bounded type

    //

    verify(v0, spec<short>(), "[V] 88");

    verify(v1, spec<char>(), "[V] X");

 }

 int test_main(int , char* [])

 {

 std_log(LOG_FILENAME_LINE,"[Test Case for test2]");

    run();

  #ifdef __SYMBIAN32__

    	testResultXml("test2");

 	close_log_file();

 #endif

    return 0;

 }