testdata.cxx

这是国外的resip协议栈

#include "rutil/Data.hxx"
#include "rutil/DataStream.hxx"
#include "rutil/Log.hxx"
#include "assert.h"
#include <iostream>

using namespace resip;
using namespace std;

// for friends
class TestData
{
   public:
      int main()
      {
         Log::initialize(Log::Cout, Log::Debug, Data::Empty);

	 {
	   const char* txt = "buffer";
	   Data d(txt);
	   // copies
	   assert(txt != d.data());

	   const char* b = d.data();
	   d.c_str();
	   // not reallocated
	   assert(b == d.data());
	 }
	 
	 {
	   const char* txt = "buffer";
	   Data d(Data::Share, txt, strlen(txt));
	   // shared
	   assert(txt == d.data());

	   d.c_str();
	   // reallocated
	   assert(txt != d.data());
	 }

	 {
	   const char* txt = "buffer";
	   Data d(Data::Borrow, txt, strlen(txt));
	   // shared
	   assert(txt == d.data());
	   const char* b = d.data();

	   d.c_str();
	   // reallocated
	   assert(b != d.data());
	 }

	 {
	   const int s = 12;
	   char* txt = new char[s];
	   Data d(Data::Take, txt, s);
	   // shared
	   assert(txt == d.data());

	   d.c_str();
	   // reallocated
	   assert(txt != d.data());
	 }

         {
            {
               int length = 16;
               char* buffer = new char [length];
   
               for (int i=0; i<16; ++i)
               {
                  buffer[i] = ' ';
               }
   
               Data target(Data::Take, buffer, length);
               std::cerr << target.c_str() << endl;
            }
            
            {
               Data input("abcdefghij");
               std::cerr << "T0: " << input << std::endl;
               input.replace("a", "b");
               std::cerr << "T1: " << input << std::endl;
               assert(input == "bbcdefghij");
               input.replace("bb", "");
               std::cerr << "T2: " << input << std::endl;
               assert(input == "cdefghij");
            }
            {
               Data input("");
               std::cerr << "T0: " << input << std::endl;
               input.replace("a", "b");
               std::cerr << "T1: " << input << std::endl;
               assert(input == "");
               input.replace("bb", "");
               std::cerr << "T2: " << input << std::endl;
               assert(input == "");
            }

            {
               Data from;
               Data to;
               Data example;

               // asserts
               //example.replace(from, to);
            }

            {
               Data from("a");
               Data to("b");
               Data example;

               example.replace(from, to);
               assert(example.empty());
            }

            {
               Data from("a");
               Data to("b");
               Data example("c");

               example.replace(from, to);
               assert(example == "c");
            }

            {
               Data from("a");
               Data to("b");
               Data example("a");

               example.replace(from, to);
               assert(example == "b");
            }

            {
               Data from("a");
               Data to("b");
               Data example("aaaa");

               example.replace(from, to);
               assert(example == "bbbb");
            }
	    
            {
               Data from("a");
               Data to("b");
               Data example("abracadabra");

               example.replace(from, to);
               assert(example == "bbrbcbdbbrb");
            }

            {
               Data from("aa");
               Data to("b");
               Data example("aa");

               example.replace(from, to);
               assert(example == "b");
            }

            {
               Data from("aa");
               Data to("b");
               Data example("aaaaa");

               example.replace(from, to);
               assert(example == "bba");
            }

            {
               Data from("a");
               Data to("bb");
               Data example("a");

               example.replace(from, to);
               assert(example == "bb");
            }

            {
               Data from("a");
               Data to("bb");
               Data example("abracadabra");

               example.replace(from, to);
               assert(example == "bbbrbbcbbdbbbrbb");
            }

            {
               Data from("a");
               Data to("bb");
               char* buffer = "abracadabra";
               Data example(Data::Share, buffer, strlen(buffer));

               example.replace(from, to);
               assert(example == "bbbrbbcbbdbbbrbb");
            }

            {
               Data from("a");
               Data to("aa");
               Data example("a");

               example.replace(from, to);
               assert(example == "aa");
            }

            {
               Data from("a");
               Data to("aa");
               Data example("abracadabra");

               example.replace(from, to);
               assert(example == "aabraacaadaabraa");
            }
	    
            {
               Data from("abracadabra");
               Data to("a");
               Data example("abracadabra");

               example.replace(from, to);
               assert(example == "a");
            }

            {
               Data from("abracadabra");
               Data to("");
               Data example("abracadabra");

               example.replace(from, to);
               assert(example == "");
            }

            {
               Data from("abracadabra");
               Data to("");
               Data example("abracadabraabracadabraabracadabra");

               example.replace(from, to);
               assert(example == "");
            }
         }

         {
            Data input("abc123abca");
            std::cerr << "T0: " << input << std::endl;
            input.replace("abc", "ABCD");
            std::cerr << "T1: " << input << std::endl;
            assert(input == "ABCD123ABCDa");
         }
         
         
         {
            const char* s = "a";
            const char* ss = "bb";
            const char* sss = "ccc";

            Data one;
            Data two;
            Data three;

            for (int i = 0; i < 100; ++i)
            {
               one.append(s, strlen(s));
               two.append(ss, strlen(ss));
               three.append(sss, strlen(sss));
            }

            assert(one.size() == 100);
            assert(two.size() == 200);
            assert(three.size() == 300);
         }

         {
            Data httpString("safe");

            Data enc;
            enc = httpString.urlEncoded();

            cerr << "res: " << enc << endl;
         }

         {
            Data httpString("-_.~!$'()*,;=:@/?");
            httpString += "0123456789";

            Data result;
            {
               DataStream str(result);
               httpString.urlEncode(str);
            }
            assert(result == httpString.urlEncoded());
            cerr << ">> " << httpString.urlEncoded() << endl;
            cerr << "<< " << httpString.urlEncoded().urlDecoded() << endl;
            cerr << ".. " << httpString << endl;

            assert(httpString == httpString.urlEncoded().urlDecoded());
            assert(result == httpString);
         }

         {
            Data httpString("http::/foo.com/in word?arg1=\"quote%\"&arg2=\"%%%%%\"");

            Data result;
            {
               DataStream str(result);
               httpString.urlEncode(str);
            }

            cerr << result << endl;
            assert(result == "http::/foo.com/in+word?arg1=%22quote%25%22%26arg2=%22%25%25%25%25%25%22");
            assert(result == httpString.urlEncoded());

            cerr << ">> " << httpString.urlEncoded() << endl;
            cerr << "<< " << httpString.urlEncoded().urlDecoded() << endl;
            cerr << ".. " << httpString << endl;

            assert(httpString == httpString.urlEncoded().urlDecoded());
         }

         {
            Data needsCharEncode("CharEncode % me");
            cerr << "original " << needsCharEncode << endl;
            cerr << "charEncoded " << needsCharEncode.charEncoded() << endl;
            cerr << "charUnencoded " << needsCharEncode.charEncoded().charUnencoded() << endl;

            assert(needsCharEncode.charEncoded().charUnencoded() == needsCharEncode);
         }

         {
            Data needsCharEncode("CharEncode % me");
            needsCharEncode += " \";/?:@&=+%$,/t-_.!~*'()";
            needsCharEncode += char(0);
            needsCharEncode += char(254);
            needsCharEncode += char(17);

            cerr << needsCharEncode.charEncoded() << endl;

            assert(needsCharEncode.charEncoded().charUnencoded() == needsCharEncode);
         }

         {
            Data needsNoCharEncode("dontcharEncodeme");

            cerr << needsNoCharEncode.charEncoded() << endl;

            assert(needsNoCharEncode.charEncoded().charUnencoded() == needsNoCharEncode);            
         }

         {
            Data s1;
            assert(s1.convertInt() == 0);
            
            Data s2("12foo");
            assert(s2.convertInt() == 12);
            
            Data s3("12");
            assert(s3.convertInt() == 12);

            Data s4("foo");
            assert(s4.convertInt() == 0);

	    Data s5("     ");
	    assert(s5.convertInt() == 0);

	    Data s6("    +");
	    assert(s6.convertInt() == 0);

	    Data s7("    +17");
	    assert(s7.convertInt() == 17);

	    Data s8("    -17");
	    assert(s8.convertInt() == -17);

	    Data s9("    --17");
	    assert(s9.convertInt() == 0);
         }

         {
            Data s1;
            assert(s1.convertUnsignedLong() == 0);
            
            Data s2("12foo");
            assert(s2.convertUnsignedLong() == 12);
            
            Data s3("12");
            assert(s3.convertUnsignedLong() == 12);

            Data s4("foo");
            assert(s4.convertUnsignedLong() == 0);

	    Data s5("     ");
	    assert(s5.convertUnsignedLong() == 0);

	    Data s6("    +");
	    assert(s6.convertUnsignedLong() == 0);

	    Data s7("    +17");
	    assert(s7.convertUnsignedLong() == 17);

	    Data s8("    -17");
	    assert(s8.convertUnsignedLong() == 0);
         }

         {
            Data s1;
            assert(s1.convertUInt64() == 0);
            
            Data s2("12foo");
            assert(s2.convertUInt64() == 12);
            
            Data s3("12");
            assert(s3.convertUInt64() == 12);

            Data s4("foo");
            assert(s4.convertUInt64() == 0);

	    Data s5("     ");
	    assert(s5.convertUInt64() == 0);

	    Data s6("    +");
	    assert(s6.convertUInt64() == 0);

	    Data s7("    +17");
	    assert(s7.convertUInt64() == 17);

	    Data s8("    -17");
	    assert(s8.convertUInt64() == 0);
         }

         {
            Data s1;
            assert(s1.convertSize() == 0);
            
            Data s2("12foo");
            assert(s2.convertSize() == 12);
            
            Data s3("12");
            assert(s3.convertSize() == 12);

            Data s4("foo");
            assert(s4.convertSize() == 0);

	    Data s5("     ");
	    assert(s5.convertSize() == 0);

	    Data s6("    +");
	    assert(s6.convertSize() == 0);