#ifndef  __BSL_TEST_AUTO_BUFFER_H_
#define  __BSL_TEST_AUTO_BUFFER_H_
#include <cxxtest/TestSuite.h>
#include <bsl/AutoBuffer.h>
#include <bsl/pool/bsl_xcompool.h>
#include<typeinfo>
#include<iostream>
#define see(x) do{      std::cerr<<__FILE__<<":"<<__LINE__<<": " <<(#x)<<" = "<<(x)<<" ("<<typeid(x).name()<<")"<<std::endl;}while(0)

#define CXM_ASSERTF( expr, fmt, arg... ) do{       static char __CXM_MSG__[1024];      TSM_ASSERT( (snprintf( __CXM_MSG__, 1024, fmt, ##arg ), __CXM_MSG__ ), expr )  }while(0)

bsl::xmempool g_xmempool;
char g_membuf[1024];

class test_AutoBuffer_main : public CxxTest::TestSuite {
public:

    void test_std_string(){
        bsl::AutoBuffer buf(0);
        std::string str("happy");
        buf << str;
        TS_ASSERT( strcmp(buf.c_str(),str.c_str()) == 0 );
        TS_ASSERT( buf.size() == str.length() );
    }
        
    void test_single_a(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_b(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_c(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_d(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_e(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_f(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_g(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_h(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_i(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_j(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ba(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bb(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bc(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bd(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_be(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bf(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bh(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bi(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bj(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ca(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cb(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cc(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cd(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ce(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cf(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ch(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ci(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cj(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_da(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_db(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dc(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dd(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_de(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_df(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dh(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_di(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dj(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ea(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eb(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ec(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ed(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ee(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ef(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eh(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ei(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ej(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fa(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fb(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fc(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fd(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fe(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ff(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fh(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fi(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fj(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ga(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gb(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gc(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gd(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ge(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gf(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gh(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gi(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_gj(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ha(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hb(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hc(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hd(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_he(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hf(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hg(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hh(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hi(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_hj(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ia(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ib(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ic(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_id(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ie(){
        bsl::AutoBuffer buf(0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_if(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ig(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ih(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ii(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ij(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ja(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jc(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jd(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_je(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jf(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jh(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ji(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_jj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_baa(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bab(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bac(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bad(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bae(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_baf(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bag(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bah(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bai(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_baj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bba(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbc(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbd(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbe(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbf(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbh(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbi(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bbj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bca(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bcb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bcc(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bcd(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bce(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bcf(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bcg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bch(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bci(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bcj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bda(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdc(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdd(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bde(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdf(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdh(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdi(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bdj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bea(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_beb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bec(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bed(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bee(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bef(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_beg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_beh(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bei(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bej(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfa(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfc(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfd(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfe(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bff(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfh(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfi(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bfj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bga(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgb(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgc(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgd(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bge(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgf(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgg(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgh(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgi(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bgj(){
        bsl::AutoBuffer buf(1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bha(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhc(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhd(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhe(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhf(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhg(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhh(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhi(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bhj(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bia(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bib(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bic(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bid(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bie(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bif(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_big(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bih(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bii(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bij(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bja(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjc(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjd(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bje(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjf(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjg(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjh(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bji(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_bjj(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_caa(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cab(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cac(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cad(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cae(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_caf(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cag(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cah(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cai(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_caj(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cba(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbc(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbd(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbe(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbf(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbg(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbh(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbi(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cbj(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cca(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ccb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ccc(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ccd(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cce(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ccf(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ccg(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cch(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cci(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ccj(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cda(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdc(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdd(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cde(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdf(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdg(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdh(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdi(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cdj(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cea(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ceb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cec(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ced(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cee(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cef(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ceg(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ceh(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cei(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cej(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfa(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfb(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfc(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfd(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfe(){
        bsl::AutoBuffer buf(100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cff(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cfj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cga(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cge(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cgj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cha(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_che(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_chj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cia(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cib(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cic(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cid(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cie(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cif(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cig(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cih(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cii(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cij(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cja(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cje(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cji(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_cjj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_daa(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dab(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dac(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dad(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dae(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_daf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dag(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dah(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dai(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_daj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dba(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbe(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dbj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dca(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dcb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dcc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dcd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dce(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dcf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dcg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dch(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dci(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dcj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dda(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dde(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ddj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dea(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_deb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dec(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ded(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dee(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_def(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_deg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_deh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dei(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dej(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfa(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfe(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dff(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dfj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dga(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dge(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dgj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dha(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhe(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dhj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dia(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dib(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dic(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_did(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_die(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dif(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dig(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dih(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dii(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dij(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dja(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dje(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_dji(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_djj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eaa(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eab(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eac(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ead(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eae(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eaf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eag(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eah(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eai(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eaj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eba(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebe(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ebj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eca(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ecb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ecc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ecd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ece(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ecf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ecg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ech(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eci(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ecj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eda(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ede(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_edj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eea(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eeb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eec(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eed(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eee(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eef(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eeg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eeh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eei(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eej(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efa(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efe(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eff(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_efj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ega(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ege(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_egj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eha(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehe(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehi(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ehj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eia(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eib(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eic(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eid(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eie(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eif(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eig(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eih(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eii(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eij(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eja(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejb(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejc(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejd(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eje(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejg(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejh(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_eji(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_ejj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_faa(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fab(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fac(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fad(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fae(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_faf(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fag(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fah(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fai(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_faj(){
        // init pool
        bsl::xcompool g_xcompool;
        g_xcompool.create();
        bsl::AutoBuffer buf(g_xcompool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }

    }


    void test_single_fba(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fbj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fca(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fcb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fcc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fcd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fce(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fcf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fcg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fch(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fci(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fcj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fda(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fde(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fdj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fea(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_feb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fec(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fed(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fee(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fef(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_feg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_feh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fei(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fej(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffa(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fff(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ffj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fga(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fge(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fgj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fha(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fhj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fia(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fib(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fic(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fid(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fie(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fif(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fig(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fih(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fii(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fij(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fja(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fje(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,0);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 0 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fji(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_fjj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gaa(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gab(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gac(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gad(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gae(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gaf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gag(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gah(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gai(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gaj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gba(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gbj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gca(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gcb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gcc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gcd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gce(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gcf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gcg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gch(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gci(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gcj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gda(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gde(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gdj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gea(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_geb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gec(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ged(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gee(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gef(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_geg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_geh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gei(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gej(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfa(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gff(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gfj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gga(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gge(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ggj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gha(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_ghj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,1);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 1 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gia(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value);
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gib(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value;
        const char * result = "true";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gic(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf.push(value).push(value).push(value);
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gid(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = true;
        buf<<value<<value<<value;;
        const char * result = "truetruetrue";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gie(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value);
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gif(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value;
        const char * result = "false";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gig(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf.push(value).push(value).push(value);
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gih(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bool value = false;
        buf<<value<<value<<value;;
        const char * result = "falsefalsefalse";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gii(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gij(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gja(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        char value = 'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gje(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value;
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gji(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf.push(value).push(value).push(value);
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_gjj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = 123;
        buf<<value<<value<<value;;
        const char * result = "123123123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_haa(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value);
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hab(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value;
        const char * result = "-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hac(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf.push(value).push(value).push(value);
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_had(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        int value = -456;
        buf<<value<<value<<value;;
        const char * result = "-456-456-456";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hae(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value);
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_haf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value;
        const char * result = "0";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hag(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf.push(value).push(value).push(value);
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hah(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = 0;
        buf<<value<<value<<value;;
        const char * result = "000";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hai(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value);
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_haj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value;
        const char * result = "-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hba(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf.push(value).push(value).push(value);
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        double value = -1e+100;
        buf<<value<<value<<value;;
        const char * result = "-1e+100-1e+100-1e+100";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value);
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value;
        const char * result = """";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf.push(value).push(value).push(value);
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "";
        buf<<value<<value<<value;;
        const char * result = """""""";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value);
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value;
        const char * result = "hello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf.push(value).push(value).push(value);
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hbj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "hello world";
        buf<<value<<value<<value;;
        const char * result = "hello worldhello worldhello world";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hca(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value);
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hcb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value;
        const char * result = "込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hcc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf.push(value).push(value).push(value);
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hcd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const char *  value = "込込";
        buf<<value<<value<<value;;
        const char * result = "込込込込込込";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hce(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value);
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hcf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value;
        const char * result = "c";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hcg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf.push(value).push(value).push(value);
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hch(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        wchar_t value = L'c';
        buf<<value<<value<<value;;
        const char * result = "ccc";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hci(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value);
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hcj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value;
        const char * result = "hello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hda(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf.push(value).push(value).push(value);
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        const wchar_t * value = L"hello";
        buf<<value<<value<<value;;
        const char * result = "hellohellohello";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value);
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value;
        const char * result = "99";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hde(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf.push(value).push(value).push(value);
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdf(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        unsigned char value = 99;
        buf<<value<<value<<value;;
        const char * result = "999999";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value);
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value;
        const char * result = "127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf.push(value).push(value).push(value);
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hdj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = 127;
        buf<<value<<value<<value;;
        const char * result = "127127127";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hea(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value);
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_heb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value;
        const char * result = "-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hec(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf.push(value).push(value).push(value);
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hed(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        signed char value = -128;
        buf<<value<<value<<value;;
        const char * result = "-128-128-128";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hee(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hef(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" ).pushf( "abc[%d]\n%s", 123, "acumon" );
        const char * result = "abc[123]\nacumonabc[123]\nacumonabc[123]\nacumon";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_heg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 3, 'a');
        const char * result = "aaa";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_heh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 0, 'a');
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hei(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 4 );
        const char * result = "auto";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hej(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "auto_buffer", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfa(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "", 0 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( "abc", 2 );
        const char * result = "ab";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( (const char *)(NULL), 100 );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfe(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf << char(0);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hff(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfg(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 10, char(0) );
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfh(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push( 123 );
        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfi(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.clear();
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hfj(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hga(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hgb(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hgc(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf1.push(123);
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hgd(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        bsl::AutoBuffer buf1;
        buf.transfer_from(buf1);
        buf1.push(123);
        buf.swap(buf1);
        buf1.transfer_from(buf);
        const char * result = "";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


    void test_single_hge(){
        // init pool
        g_xmempool.create(g_membuf,sizeof(g_membuf));
        bsl::AutoBuffer buf(g_xmempool,100);
        TS_ASSERT( buf.empty() );
        TS_ASSERT( !buf.truncated() );

        if ( 100 != 0 ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }


        buf.push(123);
        bsl::AutoBuffer buf1;
        buf1.transfer_from(buf);
        buf.push(123);
        const char * result = "123";



        if ( 0 != strcmp( result, buf.c_str() ) ){
            see(buf.capacity());
            see(buf.size());
            see(strlen(result));
            see(buf.c_str());
            see(result);
        }
        TS_ASSERT( buf.size()  == strlen(result) );
        TS_ASSERT( buf.capacity() >= buf.size() );
        TS_ASSERT( 0 == strcmp( buf.c_str(), result ) );
        TS_ASSERT( !buf.truncated() );

        if ( buf.size() != 0 ){
            TS_ASSERT( !buf.empty() );
        }else{
            TS_ASSERT( buf.empty() );
        }

        if ( buf.size() != buf.capacity() ){
            TS_ASSERT( !buf.full() );
        }else{
            TS_ASSERT( buf.full() );
        }

        size_t old_capacity = buf.capacity();
        buf.clear();
        TS_ASSERT( buf.size() == 0 );
        TS_ASSERT( old_capacity == buf.capacity() );
        TS_ASSERT( buf.empty() );
        if ( old_capacity ){
            TS_ASSERT( !buf.full() );
        }
        g_xmempool.clear();

    }


};
#endif  //__BSL_TEST_AUTO_BUFFER_H_