//  (C) Copyright Christian Leutloff 2009. Permission to copy, use, modify, sell and
//  distribute this software is granted provided this copyright notice appears
//  in all copies. This software is provided "as is" without express or implied
//  warranty, and with no claim as to its suitability for any purpose.

// 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)

//  libs/uuid/test/test_guid.cpp  -------------------------------//

#include <boost/uuid.hpp>

#include <boost/test/included/test_exec_monitor.hpp>
#include <boost/test/test_tools.hpp>

#include <boost/lexical_cast.hpp>
#include <boost/cast.hpp> 
#include <boost/lexical_cast.hpp> 
#include <boost/static_assert.hpp>
#include <string>

// This is intended to work on Windows systems where "struct GUID" is defined, too.
// Please include the converter somewhere into boost::uuid, perhaps 
// in the windows specific file boost/uuid/windows_generator.hpp.
// I am not aware of a portable version of "struct GUID".

/// helper to convert a GUID to a boost::uuid.
inline boost::uuid uuid(GUID const& guid)
{
    BOOST_STATIC_ASSERT(sizeof(guid.Data1) == 4);
    BOOST_STATIC_ASSERT(sizeof(guid.Data2) == 2);
    BOOST_STATIC_ASSERT(sizeof(guid.Data3) == 2);
    BOOST_STATIC_ASSERT(sizeof(guid.Data4) == 8);

    boost::uuid u = boost::uuid();
    u.data_[0] = boost::numeric_cast<boost::uuid::value_type>(guid.Data1 >> 24);
    u.data_[1] = boost::numeric_cast<boost::uuid::value_type>((guid.Data1 >> 16) % 0x100u);
    u.data_[2] = boost::numeric_cast<boost::uuid::value_type>((guid.Data1 >> 8) % 0x100u);
    u.data_[3] = boost::numeric_cast<boost::uuid::value_type>(guid.Data1 % 0x100u);
    u.data_[4] = boost::numeric_cast<boost::uuid::value_type>(guid.Data2 >> 8);
    u.data_[5] = boost::numeric_cast<boost::uuid::value_type>(guid.Data2 % 0x100u);
    u.data_[6] = boost::numeric_cast<boost::uuid::value_type>(guid.Data3 >> 8);
    u.data_[7] = boost::numeric_cast<boost::uuid::value_type>(guid.Data3 % 0x100u);
    for (size_t i = 0; 8 > i; ++i)
    {
        u.data_[i+8] = boost::numeric_cast<boost::uuid::value_type>(guid.Data4[i]);
    }
    return u;
}

/// copied from boost/uuid/windows_generator.hpp - but does NOT work as expected.
inline boost::uuid uuidWrong(GUID const& guid)
{
    const unsigned char *p = reinterpret_cast<const unsigned char *>(&guid);
    boost::uuid u;
    u.assign(p, p + sizeof(guid));
    return u;
}

/// helper to convert a boost::uuid to a GUID.
inline GUID guid(boost::uuid const& u)
{
    GUID guid;
    guid.Data1 = boost::numeric_cast<unsigned long>((u.data_[0] << 24) + (u.data_[1] << 16) + (u.data_[2] << 8) + u.data_[3]);
    guid.Data2 = boost::numeric_cast<unsigned short>((u.data_[4] << 8) + u.data_[5]);
    guid.Data3 = boost::numeric_cast<unsigned short>((u.data_[6] << 8) + u.data_[7]);
    for (size_t i = 0; 8 > i; ++i)
    {
        guid.Data4[i] = boost::numeric_cast<unsigned char>(u.data_[i+8]);
    }
    return guid;
}



int test_main(int, char*[])
{
    GUID guid1;
	guid1.Data1 = 0x676aecf4uL;
	guid1.Data2 = 0xcdefu;
	guid1.Data3 = 0x11deu;
	guid1.Data4[0] = 0x12u; guid1.Data4[1] = 0x34u; guid1.Data4[2] = 0x56u; guid1.Data4[3] = 0x78u;
	guid1.Data4[4] = 0x90u; guid1.Data4[5] = 0x12u; guid1.Data4[6] = 0x34u; guid1.Data4[7] = 0x56u;

	
    boost::uuid uuid1 = uuid(guid1);
    BOOST_CHECK_EQUAL("676aecf4-cdef-11de-1234-567890123456", boost::lexical_cast<std::string>(uuid1)); 

    const boost::uuid uuid1b = uuidWrong(guid1);
    BOOST_CHECK_EQUAL("f4ec6a67-efcd-de11-1234-567890123456", boost::lexical_cast<std::string>(uuid1b)); 
	

    GUID guid2 = guid(uuid1);
    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(uuid(guid1)), boost::lexical_cast<std::string>(uuid(guid2))); 
    BOOST_CHECK_EQUAL("676aecf4-cdef-11de-1234-567890123456", boost::lexical_cast<std::string>(uuid(guid2))); 
	
    return 0;
}