testdata2.cxx

RTP协议

#include <set>
#include "Data2.hxx"
#include "CopyOnWriteData.hxx"
#include "DataException.hxx"

int
main()
{
   {
      {
         Data c('c');
         assert(c == "c");
         assert(c.length() == 1);
      }
      
      {
         Data z(0);
         assert(z == "0");
         assert(z.length() == 1);
         
         Data i(123);
         assert(i == "123");
         assert(i.length() == 3);

         unsigned long vul = 12345678;
         Data ul(vul);
         cerr << "!!! " << ul << endl;
         assert(ul == "12345678");
         assert(ul.length() == 8);

         unsigned long vulz = 0;
         Data ulz(vulz);
         assert(ulz == "0");
         assert(ulz.length() == 1);

         Data dz(0.0);
         cerr << "!! " << dz << endl;
         assert(dz == "0.0");         
         assert(dz.length() == 3);

         Data dz3(0.0, 3);
         cerr << "!! " << dz << endl;
         assert(dz3 == "0.0");
         assert(dz3.length() == 3);

         Data d0(123.0);
         assert(d0 == "123.0");
         assert(d0.length() == 5);

         Data d(123.12345678);
         assert(d == "123.1235");
         assert(d.length() == 8);

         Data dp(123.12345678, 6);
         cerr << "!! " << dp << endl;
         assert(dp == "123.123457");
         assert(dp.length() == 10);

         Data in(-123);
         assert(in == "-123");
         assert(in.length() == 4);

         Data dn(-123.12345678);
         cerr << "!! " << dn << endl;
         assert(dn == "-123.1235");
         cerr << "!! " << dn.length() << endl;
         assert(dn.length() == 9);

         Data d0n(-123);
         assert(d0n == "-123");
         assert(d0n.length() == 4);

         Data ndp(-123.12345678, 6);
         assert(ndp == "-123.123457");
         assert(ndp.length() == 11);

         Data dot02(0.02);
         cerr << dot02 << endl;
         assert(dot02 == "0.02");
         assert(dot02.length() == 4);

         Data b1(true);
         assert(b1 == "true");
         assert(b1.length() == 4);
         
         Data b0(false);
         assert(b0 == "false");
         assert(b0.length() == 5);
      }

      {
         Data d1("123\r\n456\r\n");
         assert(d1.removeLWS() == "123\r\n456\r\n");

         Data d2("123\r\n   456\r\n");
         assert(d2.removeLWS() == "123     456\r\n");

         Data d3("123\n   456\r\n");
         assert(d3.removeLWS() == "123\n   456\r\n");

         Data d4("   123\r\n   456\r\n");
         assert(d4.removeLWS() == "   123     456\r\n");

         Data d5("   123\r\n   456\r\n");
         assert(d5.removeLWS() == "   123     456\r\n");

         Data d6("   1\t23\t\r\n  \t 456\r\n");
         assert(d6.removeLWS() == "   1\t23\t    \t 456\r\n");

         Data d7("A\r\n\r\nB\r\n");
         assert(d7.removeLWS() == "A\r\n\r\nB\r\n");
         
         Data d8("1\t23\t\r\n  \t 456\r\n\t\t     \r\n    \r\nfoo\r\n");
         assert(d8.removeLWS() == "1\t23\t    \t 456  \t\t           \r\nfoo\r\n");
      }
      
      {
         Data d("abcdef");
         assert(d.getChar(0) == 'a');
         assert(d.getChar(1) == 'b');
         assert(d.getChar(2) == 'c');
         assert(d.getChar(3) == 'd');
         assert(d.getChar(4) == 'e');
         assert(d.getChar(5) == 'f');

         d.setchar(0,'0');
         assert(d.getChar(0) == '0');
         d.setchar(5,'1');
         assert(d.getChar(5) == '1');            
         d.setchar(6,'2');
         assert(d.getChar(6) == '2');

         Data e;
         e.setchar(0,'a');
         assert(e == "a");
         e.setchar(5,'b');
         assert(e.getChar(5) == 'b');
         assert(e == "a");         
      }
      
      {
         assert(Data(0) == "0");
         assert(Data(1) == "1");
         assert(Data(-1) == "-1");
         assert(Data(11) == "11");      
         assert(Data(1234567) == "1234567");
         assert(Data(-1234567) == "-1234567");
      }

      {
         Data mixed("MiXed");
         assert(mixed.lowercase() == "mixed");
         cerr << "uppercase[" << mixed.uppercase() << "]" << endl;
         assert(mixed.uppercase() == "MIXED");
      
         Data e;
         assert(e.uppercase() == "");
      
         Data m("1234!@#$!@aA#$2354");
         assert(m.lowercase() == "1234!@#$!@aa#$2354");
         assert(m.uppercase() == "1234!@#$!@AA#$2354");
      }
   
      {
         Data e("");
         cerr << e.find("") << endl;
         assert(e.find("") == Data::npos);
         assert(e.find("a") == Data::npos);

         Data d;
         assert(d.find("") == Data::npos);
         assert(d.find("a") == Data::npos);
      
         Data f("asdfasdfrafs");
         assert(f.find("") == 0);
         assert(f.find("a") == 0);
         assert(f.find("asdfasdfrafs") == 0);
         assert(f.find("fs") == 10);
         assert(f.find("fr") == 7);
         assert(f.find("...") == Data::npos);
         assert(f.find("waytoolargetofind") == Data::npos);

         assert(f.find(Data("")) == 0);
         assert(f.find(Data("a")) == 0);
         assert(f.find(Data("asdfasdfrafs")) == 0);
         assert(f.find(Data("fs")) == 10);
         assert(f.find(Data("fr")) == 7);
      }
      
      {
         Data empt;
         Data empt1;
         assert(empt.length() == 0);
         assert(empt == empt);
         assert(empt == empt1);
         assert(empt1 == empt);
         assert(empt1 == "");

         assert(!(empt != empt));
         assert(!(empt != empt1));
         assert(!(empt1 != empt));
         assert(!(empt1 != ""));
      
         assert("" == empt1);
         assert("sdf" != empt1);
         assert(Data("SAfdsaf") != empt1);
         empt = empt;
         empt = empt1;
         empt = "sdfasf";
      }
      {   
         Data a("a");
         Data b("b");
         assert(a != b);
         assert(a < b);
         a = b;
         assert(a==b);
         Data c(a);
         assert(c==a);
         assert(c==b);
         assert(a==b);
      }
   
      {
         char* tmp = "sadfasdf";
         Data c(tmp, strlen(tmp));
         Data d(c);
         Data e(string("sdgdsg"));
         assert(c < e);
         assert(e > c);
         assert(c < "zzz");
         assert(c > "aaa");
         assert(!(c > c));
         assert(!(c < c));
      }
      {
         char* tmp = "sadfasdf";
         Data c(tmp, 4);
         assert(c == "sadf");
      }
      {
         Data d("qwerty");
         char buf[10];
         assert(strcmp(d.getData(buf, 10), "qwerty") == 0);
         assert(strcmp(d.getData(buf, 2), "q") == 0);
         assert(strcmp(d.getData(buf, 1), "") == 0);

         Data e;
         assert(strcmp(e.getData(buf, 10), "") == 0);
         assert(strcmp(e.getData(buf, 2), "") == 0);
         assert(strcmp(e.getData(buf, 1), "") == 0);
      }

      {
         Data d("qwerty");
         LocalScopeAllocator lo;
         assert(strcmp(d.getData(lo), "qwerty") == 0);
      }
      {
         Data e;
         LocalScopeAllocator lo;
         assert(strcmp(e.getData(lo), "") == 0);
      }   

      {
         Data d("qwerty");
         assert(strcmp(d.logData(), "qwerty") == 0);
      }
      {
         Data e;
         assert(strcmp(e.logData(), "") == 0);
      }   

      {
         Data c = "sadfsdf";
         Data d;
         d = c;
         assert(c == d);
      }
      {
         string f("asdasd");
         Data d = f;
         assert(d == f);
      }
      {
         string f("asdasd");
         Data d = f;
         assert(d.logData() == f);
      }
      {
         Data d("123");
         assert(d.length() == 3);
      }
      {
         Data d("123");
         assert(d[0] == '1');
         assert(d[1] == '2');
         assert(d[2] == '3');
      }
      {
         Data d;
         d.setBufferSize(7);
         d = "123456";
         assert(d.length() == 6);
      }
      {
         Data d("theSame1");
         string s("theSame2");
         assert(d.compare(s.c_str(), 7) == 0);
      }
      {
         Data d("thesame1");
         string s("theSame2");
         assert(d.compareNoCase(s.c_str(), s.size()-1) == 0);
      }
      {
         Data d("theSame1");
         Data e("thesame1");
         d.compareNoCase(e);
      }
      {
         Data d("one");
         Data c("two");
         d += c;
         assert(d == "onetwo");

         Data empt;
         assert(empt + d == d);
         assert(empt + d == "onetwo");
         assert(empt + "three" == "three");
      }
      
      {
         Data d("one");
         d += 'c';
         assert(d == "onec");
         assert(d.length() == 4);
      }

      {
         Data d("one");
         Data e = d + 'c';
         assert(e == "onec");
         assert(e.length() == 4);
      }
      
      {
         Data s;
         s = "c=";
         assert(s == "c=");
         s += "foo";
         assert(s == "c=foo");
         s += "\r\n";
         s += "bar";
         s += "\r\n";
         assert (s == "c=foo\r\nbar\r\n");
      }
      {
         Data a("one");
         Data b("two");
         Data c("three");
      
         assert(a+b+c == "onetwothree");
      }
   
      {
         Data d("one");
         cerr << "one + two = " << (d + "two") << endl;
         assert((d + "two") == "onetwo");
      }
      {
         Data d("asdasdasd");
         d.erase();
         assert(d.length() == 0);
      }
      {
         Data d("asdasdasd");
         string s = d.convertString();
         assert(s == "asdasdasd");
      }
      {
         Data ten("10");
         assert(ten.convertInt() == 10);

         Data neg11(-11);
         assert(-11 == neg11.convertInt());

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

         Data fr("fribble");
         assert(0 == fr.convertInt());

         Data e;
         //assert(0 == e.convertInt());
      }
      {
         Data zero("0");
         assert(zero.convertDouble() == 0.0);
         
         Data ten("10");
         assert(ten.convertDouble() == 10.0);

         Data zeroDot("0.0");
         assert(zeroDot.convertDouble() == 0.0);
         
         Data tenDot("10.0");
         assert(ten.convertDouble() == 10.0);

         Data eleven("11.11");
         assert(eleven.convertDouble() == 11.11);

         Data dotEleven("0.11");