// ----------------------------------------------------------------------------
// Copyright (C) 2002-2006 Marcin Kalicinski
//
// 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)
//
// For more information, see www.boost.org
// ----------------------------------------------------------------------------

// Intentionally no include guards (to be included more than once)

#if !defined(CHTYPE) || !defined(T) || !defined(PTREE) || !defined(NOCASE) || !defined(WIDECHAR)
#   error No character type specified
#endif

void test_debug(PTREE *)
{
#if 0
    // Check count
    BOOST_CHECK(PTREE::debug_get_instances_count() == 0);

    {

        // Create ptrees
        PTREE pt1, pt2;
        BOOST_CHECK(PTREE::debug_get_instances_count() == 2);

        // Create PTREE
        PTREE *pt3 = new PTREE;
        BOOST_CHECK(PTREE::debug_get_instances_count() == 3);

        // Insert
        pt1.push_back(std::make_pair(T("key"), *pt3));
        BOOST_CHECK(PTREE::debug_get_instances_count() == 4);

        // Insert
        pt2.push_back(std::make_pair(T("key"), *pt3));
        BOOST_CHECK(PTREE::debug_get_instances_count() == 5);

        // Clear
        pt1.clear();
        BOOST_CHECK(PTREE::debug_get_instances_count() == 4);

        // Clear
        pt2.clear();
        BOOST_CHECK(PTREE::debug_get_instances_count() == 3);

        // Delete
        delete pt3;
        BOOST_CHECK(PTREE::debug_get_instances_count() == 2);

    }

    // Check count
    BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
#endif
}

void test_constructor_destructor_assignment(PTREE *)
{

    {

        // Test constructor from string
        PTREE pt1(T("data"));
        BOOST_CHECK(pt1.data() == T("data"));
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 1);

        // Do insertions
        PTREE &tmp1 = pt1.put(T("key1"), T("data1"));
        PTREE &tmp2 = pt1.put(T("key2"), T("data2"));
        tmp1.put(T("key3"), T("data3"));
        tmp2.put(T("key4"), T("data4"));
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);

        // Make a copy using copy constructor
        PTREE *pt2 = new PTREE(pt1);
        BOOST_CHECK(*pt2 == pt1);
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 10);

        // Make a copy using = operator
        PTREE *pt3 = new PTREE;
        *pt3 = *pt2;
        BOOST_CHECK(*pt3 == *pt2);
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 15);

        // Test self assignment
        pt1 = pt1;
        BOOST_CHECK(pt1 == *pt2);
        BOOST_CHECK(pt1 == *pt3);
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 15);

        // Destroy
        delete pt2;
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 10);

        // Destroy
        delete pt3;
        //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);

    }

    // Check count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 0);

}

void test_insertion(PTREE *)
{

    // Do insertions
    PTREE pt;
    PTREE tmp1(T("data1"));
    PTREE tmp2(T("data2"));
    PTREE tmp3(T("data3"));
    PTREE tmp4(T("data4"));
    PTREE::iterator it1 = pt.insert(pt.end(), std::make_pair(T("key1"), tmp1));
    PTREE::iterator it2 = pt.insert(it1, std::make_pair(T("key2"), tmp2));
    PTREE::iterator it3 = it1->second.push_back(std::make_pair(T("key3"), tmp3));
    PTREE::iterator it4 = it1->second.push_front(std::make_pair(T("key4"), tmp4));
    it2->second.insert(it2->second.end(), it1->second.begin(), it1->second.end());

    // Check instance count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 11);

    // Check contents
    BOOST_CHECK(pt.get(T("key1"), T("")) == T("data1"));
    BOOST_CHECK(pt.get(T("key2"), T("")) == T("data2"));
    BOOST_CHECK(pt.get(T("key1.key3"), T("")) == T("data3"));
    BOOST_CHECK(pt.get(T("key1.key4"), T("")) == T("data4"));
    BOOST_CHECK(pt.get(T("key2.key3"), T("")) == T("data3"));
    BOOST_CHECK(pt.get(T("key2.key4"), T("")) == T("data4"));

    // Check sequence
    PTREE::iterator it = it2;
    ++it; BOOST_CHECK(it == it1);
    ++it; BOOST_CHECK(it == pt.end());
    it = it4; 
    ++it; BOOST_CHECK(it == it3);
    ++it; BOOST_CHECK(it == it1->second.end());

}

void test_erasing(PTREE *)
{
    
    // Do insertions
    PTREE pt;
    PTREE tmp1(T("data1"));
    PTREE tmp2(T("data2"));
    PTREE tmp3(T("data3"));
    PTREE tmp4(T("data4"));
    PTREE::iterator it1 = pt.insert(pt.end(), std::make_pair(T("key1"), tmp1));
    PTREE::iterator it2 = pt.insert(it1, std::make_pair(T("key2"), tmp2));
    it1->second.push_back(std::make_pair(T("key"), tmp3));
    it1->second.push_front(std::make_pair(T("key"), tmp4));
    it2->second.insert(it2->second.end(), it1->second.begin(), it1->second.end());

    // Check instance count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 11);

    // Test range erase
    PTREE::iterator it = it1->second.erase(it1->second.begin(), it1->second.end());
    BOOST_CHECK(it == it1->second.end());
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 9);

    // Test single erase
    PTREE::size_type n = pt.erase(T("key1"));
    BOOST_CHECK(n == 1);
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 8);

    // Test multiple erase
    n = it2->second.erase(T("key"));
    BOOST_CHECK(n == 2);
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);

    // Test one more erase
    n = pt.erase(T("key2"));
    BOOST_CHECK(n == 1);
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);

}

void test_clear(PTREE *)
{

    // Do insertions
    PTREE pt(T("data"));
    pt.push_back(std::make_pair(T("key"), PTREE(T("data"))));

    // Check instance count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 2);

    // Test clear
    pt.clear();
    BOOST_CHECK(pt.empty());
    BOOST_CHECK(pt.data().empty());
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 1);

}

void test_pushpop(PTREE *)
{

    // Do insertions
    PTREE pt;
    PTREE tmp1(T("data1"));
    PTREE tmp2(T("data2"));
    PTREE tmp3(T("data3"));
    PTREE tmp4(T("data4"));
    pt.push_back(std::make_pair(T("key3"), tmp3));
    pt.push_front(std::make_pair(T("key2"), tmp2));
    pt.push_back(std::make_pair(T("key4"), tmp4));
    pt.push_front(std::make_pair(T("key1"), tmp1));

    // Check instance count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 9);

    // Check sequence
    PTREE::iterator it = pt.begin();
    BOOST_CHECK(it->first == T("key1")); ++it;
    BOOST_CHECK(it->first == T("key2")); ++it;
    BOOST_CHECK(it->first == T("key3")); ++it;
    BOOST_CHECK(it->first == T("key4")); ++it;
    BOOST_CHECK(it == pt.end());

    // Test pops
    pt.pop_back();
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 8);
    BOOST_CHECK(pt.front().second.data() == T("data1"));
    BOOST_CHECK(pt.back().second.data() == T("data3"));
    pt.pop_front();
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 7);
    BOOST_CHECK(pt.front().second.data() == T("data2"));
    BOOST_CHECK(pt.back().second.data() == T("data3"));
    pt.pop_back();
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
    BOOST_CHECK(pt.front().second.data() == T("data2"));
    BOOST_CHECK(pt.back().second.data() == T("data2"));
    pt.pop_front();
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
    BOOST_CHECK(pt.empty());

}

void test_container_iteration(PTREE *)
{
    
    // Do insertions
    PTREE pt;
    pt.put(T("key3"), T(""));
    pt.put(T("key1"), T(""));
    pt.put(T("key4"), T(""));
    pt.put(T("key2"), T(""));

    // iterator
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it == pt.end());
    }

    // const_iterator
    {
        PTREE::const_iterator it = pt.begin();
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it == pt.end());
    }

    // reverse_iterator
    {
        PTREE::reverse_iterator it = pt.rbegin();
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it == pt.rend());
    }

    // const_reverse_iterator
    {
        PTREE::const_reverse_iterator it = pt.rbegin();
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it == PTREE::const_reverse_iterator(pt.rend()));
    }

}

void test_swap(PTREE *)
{
    
    PTREE pt1, pt2;

    // Do insertions
    pt1.put(T("key1"), T(""));
    pt1.put(T("key2"), T(""));
    pt1.put(T("key1.key3"), T(""));
    pt1.put(T("key1.key4"), T(""));

    // Check counts
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
    BOOST_CHECK(pt1.size() == 2);
    BOOST_CHECK(pt1.get_child(T("key1")).size() == 2);
    BOOST_CHECK(pt2.size() == 0);

    // Swap using member function
    pt1.swap(pt2);
    
    // Check counts
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
    BOOST_CHECK(pt2.size() == 2);
    BOOST_CHECK(pt2.get_child(T("key1")).size() == 2);
    BOOST_CHECK(pt1.size() == 0);

    // Swap using free function
    swap(pt1, pt2);

    // Check counts
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
    BOOST_CHECK(pt1.size() == 2);
    BOOST_CHECK(pt1.get_child(T("key1")).size() == 2);
    BOOST_CHECK(pt2.size() == 0);

    // Swap using std algorithm
    std::swap(pt1, pt2);

    // Check counts
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
    BOOST_CHECK(pt2.size() == 2);
    BOOST_CHECK(pt2.get_child(T("key1")).size() == 2);
    BOOST_CHECK(pt1.size() == 0);

}

void test_sort_reverse(PTREE *)
{
    
    PTREE pt;

    // Do insertions
    pt.put(T("key2"), T("data2"));
    pt.put(T("key1"), T("data1"));
    pt.put(T("key4"), T("data4"));
    pt.put(T("key3"), T("data3"));
    pt.put(T("key3.key1"), T(""));
    pt.put(T("key4.key2"), T(""));

    // Reverse
    pt.reverse();

    // Check sequence
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it == pt.end());
    }
    // Check sequence using find to check if index is ok
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it;
        BOOST_CHECK(it == pt.end());
    }

    // Sort
    pt.sort(SortPred<PTREE>());

    // Check sequence
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it == pt.end());
    }
    // Check sequence (using find to check if index is ok)
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it;
        BOOST_CHECK(it == pt.end());
    }
    
    // Sort reverse
    pt.sort(SortPredRev<PTREE>());

    // Check sequence
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it->first == T("key4")); ++it;
        BOOST_CHECK(it->first == T("key3")); ++it;
        BOOST_CHECK(it->first == T("key2")); ++it;
        BOOST_CHECK(it->first == T("key1")); ++it;
        BOOST_CHECK(it == pt.end());
    }
    // Check sequence (using find to check if index is ok)
    {
        PTREE::iterator it = pt.begin();
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it;
        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it;
        BOOST_CHECK(it == pt.end());
    }

}

void test_case(PTREE *)
{
    
    // Do insertions
    PTREE pt;
    pt.put(T("key1"), T("data1"));
    pt.put(T("KEY2"), T("data2"));
    pt.put(T("kEy1.keY3"), T("data3"));
    pt.put(T("KEY1.key4"), T("data4"));

    // Check findings depending on traits type
#if (NOCASE == 0)
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 7);
    BOOST_CHECK(pt.get(T("key1"), T("")) == T("data1"));
    BOOST_CHECK(pt.get(T("key2"), T("")) == T(""));
    BOOST_CHECK(pt.get(T("key1.key3"), T("")) == T(""));
    BOOST_CHECK(pt.get(T("KEY1.key4"), T("")) == T("data4"));
#else
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
    BOOST_CHECK(pt.get(T("key1"), T("1")) == pt.get(T("KEY1"), T("2")));
    BOOST_CHECK(pt.get(T("key2"), T("1")) == pt.get(T("KEY2"), T("2")));
    BOOST_CHECK(pt.get(T("key1.key3"), T("1")) == pt.get(T("KEY1.KEY3"), T("2")));
    BOOST_CHECK(pt.get(T("key1.key4"), T("1")) == pt.get(T("KEY1.KEY4"), T("2")));
#endif

    // Do more insertions
    pt.push_back(PTREE::value_type(T("key1"), PTREE()));
    pt.push_back(PTREE::value_type(T("key1"), PTREE()));

    // Test counts
#if (NOCASE == 0)
    BOOST_CHECK(pt.count(T("key1")) == 3);
    BOOST_CHECK(pt.count(T("KEY1")) == 1);
    BOOST_CHECK(pt.count(T("key2")) == 0);
    BOOST_CHECK(pt.count(T("KEY2")) == 1);
    BOOST_CHECK(pt.count(T("key3")) == 0);
    BOOST_CHECK(pt.count(T("KEY3")) == 0);
#else
    BOOST_CHECK(pt.count(T("key1")) == 3);
    BOOST_CHECK(pt.count(T("KEY1")) == 3);
    BOOST_CHECK(pt.count(T("key2")) == 1);
    BOOST_CHECK(pt.count(T("KEY2")) == 1);
    BOOST_CHECK(pt.count(T("key3")) == 0);
    BOOST_CHECK(pt.count(T("KEY3")) == 0);
#endif

}

void test_comparison(PTREE *)
{

    // Prepare original
    PTREE pt_orig(T("data"));
    pt_orig.put(T("key1"), T("data1"));
    pt_orig.put(T("key1.key3"), T("data2"));
    pt_orig.put(T("key1.key4"), T("data3"));
    pt_orig.put(T("key2"), T("data4"));

    // Test originals
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        BOOST_CHECK(pt1 == pt2);
        BOOST_CHECK(pt2 == pt1);
        BOOST_CHECK(!(pt1 != pt2));
        BOOST_CHECK(!(pt2 != pt1));
    }

    // Test originals with modified case
#if (NOCASE != 0)
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        pt1.pop_back();
        pt1.put(T("KEY2"), T("data4"));
        BOOST_CHECK(pt1 == pt2);
        BOOST_CHECK(pt2 == pt1);
        BOOST_CHECK(!(pt1 != pt2));
        BOOST_CHECK(!(pt2 != pt1));
    }
#endif

    // Test modified copies (both modified the same way)
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        pt1.put(T("key1.key5"), T("."));
        pt2.put(T("key1.key5"), T("."));
        BOOST_CHECK(pt1 == pt2);
        BOOST_CHECK(pt2 == pt1);
        BOOST_CHECK(!(pt1 != pt2));
        BOOST_CHECK(!(pt2 != pt1));
    }

    // Test modified copies (modified root data)
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        pt1.data() = T("a");
        pt2.data() = T("b");
        BOOST_CHECK(!(pt1 == pt2));
        BOOST_CHECK(!(pt2 == pt1));
        BOOST_CHECK(pt1 != pt2);
        BOOST_CHECK(pt2 != pt1);
    }

    // Test modified copies (added subkeys with different data)
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        pt1.put(T("key1.key5"), T("a"));
        pt2.put(T("key1.key5"), T("b"));
        BOOST_CHECK(!(pt1 == pt2));
        BOOST_CHECK(!(pt2 == pt1));
        BOOST_CHECK(pt1 != pt2);
        BOOST_CHECK(pt2 != pt1);
    }

    // Test modified copies (added subkeys with different keys)
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        pt1.put(T("key1.key5"), T(""));
        pt2.put(T("key1.key6"), T(""));
        BOOST_CHECK(!(pt1 == pt2));
        BOOST_CHECK(!(pt2 == pt1));
        BOOST_CHECK(pt1 != pt2);
        BOOST_CHECK(pt2 != pt1);
    }

    // Test modified copies (added subkey to only one copy)
    {
        PTREE pt1(pt_orig);
        PTREE pt2(pt_orig);
        pt1.put(T("key1.key5"), T(""));
        BOOST_CHECK(!(pt1 == pt2));
        BOOST_CHECK(!(pt2 == pt1));
        BOOST_CHECK(pt1 != pt2);
        BOOST_CHECK(pt2 != pt1);
    }

}

void test_front_back(PTREE *)
{
    
    // Do insertions
    PTREE pt;
    pt.put(T("key1"), T(""));
    pt.put(T("key2"), T(""));

    // Check front and back
    BOOST_CHECK(pt.front().first == T("key1"));
    BOOST_CHECK(pt.back().first == T("key2"));

}

void test_get_put(PTREE *)
{
    
    typedef std::basic_string<CHTYPE> str_t;

    // Temporary storage
    str_t tmp_string;
    boost::optional<int> opt_int;
    boost::optional<long> opt_long;
    boost::optional<double> opt_double;
    boost::optional<float> opt_float;
    boost::optional<str_t> opt_string;
    boost::optional<CHTYPE> opt_char;
    boost::optional<bool> opt_bool;
    
    // Do insertions via put
    PTREE pt;
    PTREE &pt1 = pt.put(T("k1"), 1);
    PTREE &pt2 = pt.put(T("k2.k"), 2.5);
    PTREE &pt3 = pt.put(T("k3.k.k"), T("ala ma kota"));
    PTREE &pt4 = pt.put(T("k4.k.k.k"), CHTYPE('c'));
    PTREE &pt5 = pt.put(T("k5.k.k.k.f"), false);
    PTREE &pt6 = pt.put(T("k5.k.k.k.t"), true);

    // Check instances count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 17);

    // Check if const char * version returns std::string
    BOOST_CHECK(typeid(pt.get_value(T(""))) == typeid(str_t));
    
    // Do extractions via get (throwing version)
    BOOST_CHECK(pt.get<int>(T("k1")) == 1);
    BOOST_CHECK(pt.get<long>(T("k1")) == 1);
    BOOST_CHECK(pt.get<double>(T("k2.k")) == 2.5);
    BOOST_CHECK(pt.get<float>(T("k2.k")) == 2.5f);
    BOOST_CHECK(pt.get<str_t>(T("k3.k.k")) == str_t(T("ala ma kota")));
    BOOST_CHECK(pt.get<CHTYPE>(T("k4.k.k.k")) == CHTYPE('c'));
    BOOST_CHECK(pt.get<bool>(T("k5.k.k.k.f")) == false);
    BOOST_CHECK(pt.get<bool>(T("k5.k.k.k.t")) == true);

    // Do extractions via get (default value version)
    BOOST_CHECK(pt.get(T("k1"), 0) == 1);
    BOOST_CHECK(pt.get(T("k1"), 0L) == 1);
    BOOST_CHECK(pt.get(T("k2.k"), 0.0) == 2.5);
    BOOST_CHECK(pt.get(T("k2.k"), 0.0f) == 2.5f);
    BOOST_CHECK(pt.get(T("k3.k.k"), str_t()) == str_t(T("ala ma kota")));
    BOOST_CHECK(pt.get(T("k3.k.k"), T("")) == T("ala ma kota"));
    BOOST_CHECK(pt.get(T("k4.k.k.k"), CHTYPE('\0')) == CHTYPE('c'));
    BOOST_CHECK(pt.get(T("k5.k.k.k.f"), true) == false);
    BOOST_CHECK(pt.get(T("k5.k.k.k.t"), false) == true);

    // Do extractions via get (optional version)
    opt_int = pt.get_optional<int>(T("k1"));
    BOOST_CHECK(opt_int && *opt_int == 1);
    opt_long = pt.get_optional<long>(T("k1"));
    BOOST_CHECK(opt_long && *opt_long == 1);
    opt_double = pt.get_optional<double>(T("k2.k"));
    BOOST_CHECK(opt_double && *opt_double == 2.5);
    opt_float = pt.get_optional<float>(T("k2.k"));
    BOOST_CHECK(opt_float && *opt_float == 2.5f);
    opt_string = pt.get_optional<str_t>(T("k3.k.k"));
    BOOST_CHECK(opt_string && *opt_string == str_t(T("ala ma kota")));
    opt_char = pt.get_optional<CHTYPE>(T("k4.k.k.k"));
    BOOST_CHECK(opt_char && *opt_char == CHTYPE('c'));
    opt_bool = pt.get_optional<bool>(T("k5.k.k.k.f"));
    BOOST_CHECK(opt_bool && *opt_bool == false);
    opt_bool = pt.get_optional<bool>(T("k5.k.k.k.t"));
    BOOST_CHECK(opt_bool && *opt_bool == true);

    // Do insertions via put_value
    pt1.put_value(short(1));
    pt2.put_value(2.5f);
    pt3.put_value(str_t(T("ala ma kota")));
    pt4.put_value(CHTYPE('c'));
    pt5.put_value(false);
    pt6.put_value(true);

    // Do extractions via get_value (throwing version)
    BOOST_CHECK(pt1.get_value<int>() == 1);
    BOOST_CHECK(pt1.get_value<long>() == 1);
    BOOST_CHECK(pt2.get_value<double>() == 2.5);
    BOOST_CHECK(pt2.get_value<float>() == 2.5f);
    BOOST_CHECK(pt3.get_value<str_t>() == str_t(T("ala ma kota")));
    BOOST_CHECK(pt4.get_value<CHTYPE>() == CHTYPE('c'));
    BOOST_CHECK(pt5.get_value<bool>() == false);
    BOOST_CHECK(pt6.get_value<bool>() == true);

    // Do extractions via get_value (default value version)
    BOOST_CHECK(pt1.get_value(0) == 1);
    BOOST_CHECK(pt1.get_value(0L) == 1);
    BOOST_CHECK(pt2.get_value(0.0) == 2.5);
    BOOST_CHECK(pt2.get_value(0.0f) == 2.5f);
    BOOST_CHECK(pt3.get_value(str_t()) == str_t(T("ala ma kota")));
    BOOST_CHECK(pt3.get_value(T("")) == T("ala ma kota"));
    BOOST_CHECK(pt4.get_value(CHTYPE('\0')) == CHTYPE('c'));
    BOOST_CHECK(pt5.get_value(true) == false);
    BOOST_CHECK(pt6.get_value(false) == true);

    // Do extractions via get_value (optional version)
    opt_int = pt1.get_value_optional<int>();
    BOOST_CHECK(opt_int && *opt_int == 1);
    opt_long = pt1.get_value_optional<long>();
    BOOST_CHECK(opt_long && *opt_long == 1);
    opt_double = pt2.get_value_optional<double>();
    BOOST_CHECK(opt_double && *opt_double == 2.5);
    opt_float = pt2.get_value_optional<float>();
    BOOST_CHECK(opt_float && *opt_float == 2.5f);
    opt_string = pt3.get_value_optional<str_t>();
    BOOST_CHECK(opt_string && *opt_string == str_t(T("ala ma kota")));
    opt_char = pt4.get_value_optional<CHTYPE>();
    BOOST_CHECK(opt_char && *opt_char == CHTYPE('c'));
    opt_bool = pt5.get_value_optional<bool>();
    BOOST_CHECK(opt_bool && *opt_bool == false);
    opt_bool = pt6.get_value_optional<bool>();
    BOOST_CHECK(opt_bool && *opt_bool == true);

    // Do incorrect extractions (throwing version)
    try
    {
        pt.get<int>(T("k2.k.bogus.path"));
        BOOST_ERROR("No required exception thrown");
    }
    catch (boost::property_tree::ptree_bad_path &) { }
    catch (...)
    {
        BOOST_ERROR("Wrong exception type thrown");
    }
    try
    {
        pt.get<int>(T("k2.k"));
        BOOST_ERROR("No required exception thrown");
    }
    catch (boost::property_tree::ptree_bad_data &) { }
    catch (...)
    {
        BOOST_ERROR("Wrong exception type thrown");
    }

    // Do incorrect extractions (default value version)
    BOOST_CHECK(pt.get(T("k2.k"), -7) == -7);
    BOOST_CHECK(pt.get(T("k3.k.k"), -7) == -7);
    BOOST_CHECK(pt.get(T("k4.k.k.k"), -7) == -7);

    // Do incorrect extractions (optional version)
    BOOST_CHECK(!pt.get_optional<int>(T("k2.k")));
    BOOST_CHECK(!pt.get_optional<int>(T("k3.k.k")));
    BOOST_CHECK(!pt.get_optional<int>(T("k4.k.k.k")));

    // Test multiple puts with the same key
    {
        PTREE pt;
        pt.put(T("key"), 1);
        BOOST_CHECK(pt.get<int>(T("key")) == 1);
        BOOST_CHECK(pt.size() == 1);
        pt.put(T("key"), 2);
        BOOST_CHECK(pt.get<int>(T("key")) == 2);
        BOOST_CHECK(pt.size() == 1);
        pt.put(T("key.key.key"), 1);
        PTREE &child = pt.get_child(T("key.key"));
        BOOST_CHECK(pt.get<int>(T("key.key.key")) == 1);
        BOOST_CHECK(child.size() == 1);
        BOOST_CHECK(child.count(T("key")) == 1);
        pt.put(T("key.key.key"), 2);
        BOOST_CHECK(pt.get<int>(T("key.key.key")) == 2);
        BOOST_CHECK(child.size() == 1);
        BOOST_CHECK(child.count(T("key")) == 1);
    }

    // Test multiple puts with the same key
    {
        PTREE pt;
        pt.put(T("key"), 1);
        BOOST_CHECK(pt.get<int>(T("key")) == 1);
        BOOST_CHECK(pt.size() == 1);
        pt.put(T("key"), 2);
        BOOST_CHECK(pt.get<int>(T("key")) == 2);
        BOOST_CHECK(pt.size() == 1);
        pt.put(T("key.key.key"), 1);
        PTREE &child = pt.get_child(T("key.key"));
        BOOST_CHECK(child.size() == 1);
        BOOST_CHECK(child.count(T("key")) == 1);
        pt.add(T("key.key.key"), 2);
        BOOST_CHECK(child.size() == 2);
        BOOST_CHECK(child.count(T("key")) == 2);
    }

    // Test that put does not destroy children
    {
        PTREE pt;
        pt.put(T("key1"), 1);
        pt.put(T("key1.key2"), 2);
        BOOST_CHECK(pt.get<int>(T("key1"), 0) == 1);
        BOOST_CHECK(pt.get<int>(T("key1.key2"), 0) == 2);
        pt.put(T("key1"), 2);
        BOOST_CHECK(pt.get<int>(T("key1"), 0) == 2);
        BOOST_CHECK(pt.get<int>(T("key1.key2"), 0) == 2);
    }

    // Test that get of single character that is whitespace works
    {
        PTREE pt;
        pt.put_value(T(' '));
        CHTYPE ch = pt.get_value<CHTYPE>();
        BOOST_CHECK(ch == T(' '));
    }

    // Test that get of non-char value with trailing and leading whitespace works
    {
        PTREE pt;
        pt.put_value(T(" \t\n99 \t\n"));
        BOOST_CHECK(pt.get_value<int>(0) == 99);
    }

}
                                    
void test_get_child_put_child(PTREE *)
{
    PTREE pt(T("ala ma kota"));

    // Do insertions via put_child
    PTREE pt1, pt2, pt3;
    pt1.put_child(T("k1"), PTREE());
    pt1.put_child(T("k2.k"), PTREE());
    pt2.put_child(T("k1"), pt);
    pt2.put_child(T("k2.k"), pt);

    // Const references to test const versions of methods
    const PTREE &cpt1 = pt1, &cpt2 = pt2;

    // Do correct extractions via get_child (throwing version)
    BOOST_CHECK(pt1.get_child(T("k1")).empty());
    BOOST_CHECK(pt1.get_child(T("k2.k")).empty());
    BOOST_CHECK(pt2.get_child(T("k1")) == pt);
    BOOST_CHECK(pt2.get_child(T("k2.k")) == pt);
    BOOST_CHECK(cpt1.get_child(T("k1")).empty());
    BOOST_CHECK(cpt1.get_child(T("k2.k")).empty());
    BOOST_CHECK(cpt2.get_child(T("k1")) == pt);
    BOOST_CHECK(cpt2.get_child(T("k2.k")) == pt);

    // Do correct extractions via get_child (default value version)
    BOOST_CHECK(pt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def")));
    BOOST_CHECK(pt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def")));
    BOOST_CHECK(pt2.get_child(T("k1"), PTREE(T("def"))) == pt);
    BOOST_CHECK(pt2.get_child(T("k2.k"), PTREE(T("def"))) == pt);
    BOOST_CHECK(cpt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def")));
    BOOST_CHECK(cpt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def")));
    BOOST_CHECK(cpt2.get_child(T("k1"), PTREE(T("def"))) == pt);
    BOOST_CHECK(cpt2.get_child(T("k2.k"), PTREE(T("def"))) == pt);

    // Do correct extractions via get_child (optional version)
    boost::optional<PTREE &> opt;
    boost::optional<const PTREE &> copt;
    opt = pt1.get_child_optional(T("k1"));
    BOOST_CHECK(opt);
    opt = pt1.get_child_optional(T("k2.k"));
    BOOST_CHECK(opt);
    opt = pt2.get_child_optional(T("k1"));
    BOOST_CHECK(opt && *opt == pt);
    opt = pt2.get_child_optional(T("k2.k"));
    BOOST_CHECK(opt && *opt == pt);
    copt = cpt1.get_child_optional(T("k1"));
    BOOST_CHECK(copt);
    copt = cpt1.get_child_optional(T("k2.k"));
    BOOST_CHECK(copt);
    copt = cpt2.get_child_optional(T("k1"));
    BOOST_CHECK(copt && *copt == pt);
    copt = cpt2.get_child_optional(T("k2.k"));
    BOOST_CHECK(copt && *copt == pt);

    // Do incorrect extractions via get_child (throwing version)
    try
    {
        pt.get_child(T("k2.k.bogus.path"));
        BOOST_ERROR("No required exception thrown");
    }
    catch (boost::property_tree::ptree_bad_path &) { }
    catch (...)
    {
        BOOST_ERROR("Wrong exception type thrown");
    }

    // Do incorrect extractions via get_child (default value version)
    BOOST_CHECK(&pt.get_child(T("k2.k.bogus.path"), pt3) == &pt3);

    // Do incorrect extractions via get_child (optional version)
    BOOST_CHECK(!pt.get_child_optional(T("k2.k.bogus.path")));

    // Test multiple puts with the same key
    {
        PTREE pt, tmp1(T("data1")), tmp2(T("data2"));
        pt.put_child(T("key"), tmp1);
        BOOST_CHECK(pt.get_child(T("key")) == tmp1);
        BOOST_CHECK(pt.size() == 1);
        pt.put_child(T("key"), tmp2);
        BOOST_CHECK(pt.get_child(T("key")) == tmp2);
        BOOST_CHECK(pt.size() == 1);
        pt.put_child(T("key.key.key"), tmp1);
        PTREE &child = pt.get_child(T("key.key"));
        BOOST_CHECK(child.size() == 1);
        pt.put_child(T("key.key.key"), tmp2);
        BOOST_CHECK(child.size() == 1);
    }

    // Test multiple adds with the same key
    {
        PTREE pt, tmp1(T("data1")), tmp2(T("data2"));
        pt.add_child(T("key"), tmp1);
        BOOST_CHECK(pt.size() == 1);
        pt.add_child(T("key"), tmp2);
        BOOST_CHECK(pt.size() == 2);
        BOOST_CHECK(pt.count(T("key")) == 2);
        pt.add_child(T("key.key.key"), tmp1);
        PTREE &child = pt.get_child(T("key.key"));
        BOOST_CHECK(child.size() == 1);
        BOOST_CHECK(child.count(T("key")) == 1);
        pt.add_child(T("key.key.key"), tmp2);
        BOOST_CHECK(child.size() == 2);
        BOOST_CHECK(child.count(T("key")) == 2);
    }

    // Test assigning child to tree
    {
        PTREE pt;
        pt.put(T("foo.bar"), T("baz"));
        pt = pt.get_child(T("foo"));
        BOOST_CHECK(pt.size() == 1);
        BOOST_CHECK(pt.get< std::basic_string<CHTYPE> >(T("bar")) == T("baz"));
    }

}

void test_equal_range(PTREE *)
{
    PTREE pt;
    pt.add_child(T("k1"), PTREE());
    pt.add_child(T("k2"), PTREE());
    pt.add_child(T("k1"), PTREE());
    pt.add_child(T("k3"), PTREE());
    pt.add_child(T("k1"), PTREE());
    pt.add_child(T("k2"), PTREE());

    BOOST_CHECK(boost::distance(pt.equal_range(T("k1"))) == 3);
    BOOST_CHECK(boost::distance(pt.equal_range(T("k2"))) == 2);
    BOOST_CHECK(boost::distance(pt.equal_range(T("k3"))) == 1);
}

void test_path_separator(PTREE *)
{

    typedef PTREE::path_type path;

    // Check instances count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 0);

    // Do insertions
    PTREE pt;
    pt.put(T("key1"), T("1"));
    pt.put(T("key2.key"), T("2"));
    pt.put(T("key3.key.key"), T("3"));
    pt.put(path(T("key4"), CHTYPE('/')), T("4"));
    pt.put(path(T("key5/key"), CHTYPE('/')), T("5"));
    pt.put(path(T("key6/key/key"), CHTYPE('/')), T("6"));

    // Check instances count
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 13);

    // Do correct extractions
    BOOST_CHECK(pt.get(T("key1"), 0) == 1);
    BOOST_CHECK(pt.get(T("key2.key"), 0) == 2);
    BOOST_CHECK(pt.get(T("key3.key.key"), 0) == 3);
    BOOST_CHECK(pt.get(path(T("key4"), CHTYPE('/')), 0) == 4);
    BOOST_CHECK(pt.get(path(T("key5/key"), CHTYPE('/')), 0) == 5);
    BOOST_CHECK(pt.get(path(T("key6/key/key"), CHTYPE('/')), 0) == 6);

    // Do incorrect extractions
    BOOST_CHECK(pt.get(T("key2/key"), 0) == 0);
    BOOST_CHECK(pt.get(T("key3/key/key"), 0) == 0);
    BOOST_CHECK(pt.get(path(T("key5.key"), CHTYPE('/')), 0) == 0);
    BOOST_CHECK(pt.get(path(T("key6.key.key"), CHTYPE('/')), 0) == 0);

}

void test_path(PTREE *)
{

    typedef PTREE::path_type path;

    // Insert
    PTREE pt;
    pt.put(T("key1.key2.key3"), 1);

    // Test operator /=
    {
        path p;
        p /= T("key1"); p /= T("key2"); p /= T("key3");
        BOOST_CHECK(pt.get<int>(p, 0) == 1);
    }

    // Test operator /=
    {
        path p(T("key1"));
        p /= T("key2.key3");
        BOOST_CHECK(pt.get<int>(p, 0) == 1);
    }

    // Test operator /=
    {
        path p;
        path p1(T("key1.key2"));
        path p2(T("key3"));
        p /= p1;
        p /= p2;
        BOOST_CHECK(pt.get<int>(p, 0) == 1);
    }

    // Test operator /
    {
        path p = path(T("key1")) / T("key2.key3");
        BOOST_CHECK(pt.get<int>(p, 0) == 1);
    }

    // Test operator /
    {
        path p = T("key1.key2") / path(T("key3"));
        BOOST_CHECK(pt.get<int>(p, 0) == 1);
    }

}

void test_precision(PTREE *)
{

    typedef double real;

    // Quite precise PI value
    real pi = real(3.1415926535897932384626433832795028841971);

    // Put and get
    PTREE pt;
    pt.put_value(pi);
    real pi2 = pt.get_value<real>();

    // Test if precision is "good enough", i.e. if stream precision increase worked
    using namespace std;
    real error = abs(pi - pi2) *
        pow(real(numeric_limits<real>::radix), 
            real(numeric_limits<real>::digits));
    BOOST_CHECK(error < 100);

}

void test_locale(PTREE *)
{
    typedef boost::property_tree::translator_between<
        std::basic_string<CHTYPE>, double>::type translator;
    try
    {

        // Write strings in english and french locales
        PTREE pt;
#ifdef BOOST_WINDOWS
        std::locale loc_english("english");
        std::locale loc_french("french");
#else
        std::locale loc_english("en_GB");
        std::locale loc_french("fr_FR");
#endif
        pt.put(T("english"), 1.234, translator(loc_english));
        pt.put(T("french"), 1.234, translator(loc_french));

        // Test contents
        BOOST_CHECK(pt.get<PTREE::data_type>(T("english")) == T("1.234"));
        BOOST_CHECK(pt.get<PTREE::data_type>(T("french")) == T("1,234"));

    }
    catch (boost::property_tree::ptree_error &)
    {
        throw;
    }
    catch (std::runtime_error &e)
    {
        std::cerr << "Required locale not supported by the platform. "
                     "Skipping locale tests (caught std::runtime_error with message " << 
                     e.what() << ").\n";
    }

}

void test_custom_data_type(PTREE *)
{

    typedef std::basic_string<CHTYPE> Str;
    typedef PTREE::key_compare Comp;

    // Property_tree with boost::any as data type
    typedef boost::property_tree::basic_ptree<Str, boost::any, Comp> my_ptree;
    my_ptree pt;

    // Put/get int value
    pt.put(T("int value"), 3);
    int int_value = pt.get<int>(T("int value"));
    BOOST_CHECK(int_value == 3);

    // Put/get string value
    pt.put<std::basic_string<CHTYPE> >(T("string value"), T("foo bar"));
    std::basic_string<CHTYPE> string_value = pt.get<std::basic_string<CHTYPE> >(T("string value"));
    BOOST_CHECK(string_value == T("foo bar"));

    // Put/get list<int> value
    int list_data[] = { 1, 2, 3, 4, 5 };
    pt.put<std::list<int> >(T("list value"), std::list<int>(list_data, list_data + sizeof(list_data) / sizeof(*list_data)));
    std::list<int> list_value = pt.get<std::list<int> >(T("list value"));
    BOOST_CHECK(list_value.size() == 5);
    BOOST_CHECK(list_value.front() == 1);
    BOOST_CHECK(list_value.back() == 5);

}

void test_empty_size_max_size(PTREE *)
{

    PTREE pt;
    BOOST_CHECK(pt.max_size());
    BOOST_CHECK(pt.empty());
    BOOST_CHECK(pt.size() == 0);

    pt.put(T("test1"), 1);
    BOOST_CHECK(pt.max_size());
    BOOST_CHECK(!pt.empty());
    BOOST_CHECK(pt.size() == 1);

    pt.put(T("test2"), 2);
    BOOST_CHECK(pt.max_size());
    BOOST_CHECK(!pt.empty());
    BOOST_CHECK(pt.size() == 2);

}

void test_ptree_bad_path(PTREE *)
{

    PTREE pt;

    try
    {
        pt.get<int>(T("non.existent.path"));
    }
    catch (boost::property_tree::ptree_bad_path &e)
    {
        PTREE::path_type path = e.path<PTREE::path_type>();
        std::string what = e.what();
        BOOST_CHECK(what.find("non.existent.path") != std::string::npos);
        return;
    }

    BOOST_ERROR("No required exception thrown");

}

void test_ptree_bad_data(PTREE *)
{

    PTREE pt;
    pt.put_value("non convertible to int");

    try
    {
        pt.get_value<int>();
    }
    catch (boost::property_tree::ptree_bad_data &e)
    {
        PTREE::data_type data = e.data<PTREE::data_type>();
        std::string what = e.what();
        // FIXME: Bring back what translation or make it more clear that it
        // doesn't work.
        //BOOST_CHECK(what.find("non convertible to int") != std::string::npos);
        return;
    }

    BOOST_ERROR("No required exception thrown");
}

void test_serialization(PTREE *)
{

    // Prepare test tree
    PTREE pt;
    pt.put_value(1);
    pt.put(T("key1"), 3);
    pt.put(T("key1.key11)"), 3.3);
    pt.put(T("key1.key12"), T("foo"));
    pt.put(T("key2"), true);
    pt.put(T("key2.key21.key211.key2111.key21111"), T("super deep!"));
    pt.put_child(T("empty"), PTREE());
    pt.put(T("loooooong"), PTREE::data_type(10000, CHTYPE('a')));

    // Endforce const for input
    const PTREE &pt1 = pt;
    
    // Test text archives
    {
        std::stringstream stream;
        boost::archive::text_oarchive oa(stream);
        oa & pt1;
        boost::archive::text_iarchive ia(stream);
        PTREE pt2;
        ia & pt2;
        BOOST_CHECK(pt1 == pt2);
    }
    
    // Test binary archives
    {
        std::stringstream stream;
        boost::archive::binary_oarchive oa(stream);
        oa & pt1;
        boost::archive::binary_iarchive ia(stream);
        PTREE pt2;
        ia & pt2;
        BOOST_CHECK(pt1 == pt2);
    }

    // Test XML archives
    {
        std::stringstream stream;
        boost::archive::xml_oarchive oa(stream);
        oa & boost::serialization::make_nvp("pt", pt1);
        boost::archive::xml_iarchive ia(stream);
        PTREE pt2;
        ia & boost::serialization::make_nvp("pt", pt2);
        BOOST_CHECK(pt1 == pt2);
    }

}

void test_bool(PTREE *)
{

    // Prepare test tree
    PTREE pt;
    pt.put(T("bool.false.1"), false);
    pt.put(T("bool.false.2"), T("0"));
    pt.put(T("bool.true.1"), true);
    pt.put(T("bool.true.2"), 1);
    pt.put(T("bool.invalid.1"), T(""));
    pt.put(T("bool.invalid.2"), T("tt"));
    pt.put(T("bool.invalid.3"), T("ff"));
    pt.put(T("bool.invalid.4"), T("2"));
    pt.put(T("bool.invalid.5"), T("-1"));

    // Test false
    for (PTREE::iterator it = pt.get_child(T("bool.false")).begin(); it != pt.get_child(T("bool.false")).end(); ++it)
        BOOST_CHECK(it->second.get_value<bool>() == false);

    // Test true
    for (PTREE::iterator it = pt.get_child(T("bool.true")).begin(); it != pt.get_child(T("bool.true")).end(); ++it)
        BOOST_CHECK(it->second.get_value<bool>() == true);

    // Test invalid
    for (PTREE::iterator it = pt.get_child(T("bool.invalid")).begin(); it != pt.get_child(T("bool.invalid")).end(); ++it)
    {
        BOOST_CHECK(it->second.get_value<bool>(false) == false);
        BOOST_CHECK(it->second.get_value<bool>(true) == true);
    }

}

void test_char(PTREE *)
{
    typedef signed char schar;
    typedef unsigned char uchar;

    // Prepare test tree
    PTREE pt;
#if WIDECHAR == 0
    pt.put(T("char"), char('A'));
#endif
    pt.put(T("signed char"), static_cast<schar>('A'));
    pt.put(T("unsigned char"), static_cast<uchar>('A'));
    pt.put(T("signed char min"), (std::numeric_limits<schar>::min)());
    pt.put(T("signed char max"), (std::numeric_limits<schar>::max)());
    pt.put(T("signed char underflow"),
           static_cast<int>((std::numeric_limits<schar>::min)()) - 1);
    pt.put(T("signed char overflow"),
           static_cast<int>((std::numeric_limits<schar>::max)()) + 1);
    pt.put(T("unsigned char min"), (std::numeric_limits<uchar>::min)());
    pt.put(T("unsigned char max"), (std::numeric_limits<uchar>::max)());
    pt.put(T("unsigned char overflow"),
           static_cast<unsigned>((std::numeric_limits<uchar>::max)()) + 1);

    // Verify normal conversions
#if WIDECHAR == 0
    BOOST_CHECK(pt.get<char>(T("char")) == 'A');
#endif
    BOOST_CHECK(pt.get<schar>(T("signed char")) == static_cast<schar>('A'));
    BOOST_CHECK(pt.get<uchar>(T("unsigned char")) == static_cast<uchar>('A'));

    // Verify that numbers are saved for signed and unsigned char
    BOOST_CHECK(pt.get<int>(T("signed char")) == int('A'));
    BOOST_CHECK(pt.get<int>(T("unsigned char")) == int('A'));

    // Verify ranges
    BOOST_CHECK(pt.get<schar>(T("signed char min")) ==
        (std::numeric_limits<schar>::min)());
    BOOST_CHECK(pt.get<schar>(T("signed char max")) ==
        (std::numeric_limits<schar>::max)());
    BOOST_CHECK(pt.get<uchar>(T("unsigned char min")) ==
        (std::numeric_limits<uchar>::min)());
    BOOST_CHECK(pt.get<uchar>(T("unsigned char max")) ==
        (std::numeric_limits<uchar>::max)());

    // Check that out-of-range throws.
    try {
        pt.get<schar>(T("signed char underflow"));
        BOOST_ERROR("expected ptree_bad_data, but nothing was thrown");
    } catch (boost::property_tree::ptree_bad_data&) {
    } catch (...) {
        BOOST_ERROR("expected ptree_bad_data, but something else was thrown");
    }
    try {
        pt.get<schar>(T("signed char overflow"));
        BOOST_ERROR("expected ptree_bad_data, but nothing was thrown");
    } catch (boost::property_tree::ptree_bad_data&) {
    } catch (...) {
        BOOST_ERROR("expected ptree_bad_data, but something else was thrown");
    }
    try {
        pt.get<uchar>(T("unsigned char overflow"));
        BOOST_ERROR("expected ptree_bad_data, but nothing was thrown");
    } catch (boost::property_tree::ptree_bad_data&) {
    } catch (...) {
        BOOST_ERROR("expected ptree_bad_data, but something else was thrown");
    }
}

void test_float(PTREE*)
{
    const double difficult = -183.12345000098765e-10;
    PTREE pt;
    pt.put(T("num"), difficult);
    double result = pt.get<double>(T("num"));

    BOOST_CHECK(!(result < difficult || result > difficult));
}

void test_sort(PTREE *)
{
  PTREE pt;
  pt.put(T("one"), T("v1"));
  pt.put(T("two"), T("v2"));
  pt.put(T("three"), T("v3"));
  pt.put(T("four"), T("v4"));

  pt.sort();

  PTREE::iterator it = pt.begin();
  BOOST_CHECK(std::distance(it, pt.end()) == 4);
  BOOST_CHECK(it->first == T("four"));
  BOOST_CHECK(it->second.data() == T("v4"));
  ++it;
  BOOST_CHECK(it->first == T("one"));
  BOOST_CHECK(it->second.data() == T("v1"));
  ++it;
  BOOST_CHECK(it->first == T("three"));
  BOOST_CHECK(it->second.data() == T("v3"));
  ++it;
  BOOST_CHECK(it->first == T("two"));
  BOOST_CHECK(it->second.data() == T("v2"));
}

void test_leaks(PTREE *)
{
    //BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
}