testdata.cxx

这是国外的resip协议栈

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

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

#ifndef RESIP_FIXED_POINT
         {
            Data s1;
            assert(s1.convertDouble() == 0);

            Data s2("12foo");
            assert(s2.convertDouble() == 12);

            Data s3("12");
            assert(s3.convertDouble() == 12);

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

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

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

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

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

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

         {
            Data s1(".");
            assert(s1.convertDouble() == 0);

            Data s2("12.12foo");
            assert(s2.convertDouble() == 12.12);

            Data s3("12.12");
            assert(s3.convertDouble() == 12.12);

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

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

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

            Data s6a("    -.");
            assert(s6a.convertDouble() == 0);

            Data s7("    +17.17");
            assert(s7.convertDouble() == 17.17);

            Data s8("    -17.17");
            assert(s8.convertDouble() == -17.17);

            Data s9("    -17.17foo");
            assert(s9.convertDouble() == -17.17);

            Data s10("    --17.17");
            assert(s10.convertDouble() == 0);

            Data s11("    -0000.017");
            assert(s11.convertDouble() == -0.017);

            Data s12(".017");
            assert(s12.convertDouble() == 0.017);

            Data s13("    .017");
            assert(s13.convertDouble() == 0.017);

            Data s14("    +.017");
            assert(s14.convertDouble() == 0.017);

            Data s15("    -.017");
            assert(s15.convertDouble() == -0.017);

         }
#endif
         {
            Data s;
            s = "some text";
            s += Data::Empty;
            s += "";

            assert(s == "some text");
         }

         {
            Data d;
            char *q = "\0";
            d += q;
           
            for(char *p = 
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                *p;
                ++p)
            {
               d += *p;
               d += q;
               d += "~";
            }
           
         }

         {
            Data d;
            assert(d.empty());
            assert(d.c_str()[0] == 0);
         }

         {
            const int maxs = 1024;
            Data a;
            for (int i = 0; i < maxs; i++)
            {
               Data b(a.c_str());
               Data c(b);

               a += "a";
            }
            cerr << "test data size 0.." << maxs << endl;
         }

         // test comparison
         {
            {
               Data c = "sadfsdf";
               Data d;
               d = c;
               assert(c == d);
            }

            {
               const char* f = "asdasd";
               Data d = Data(f);
               assert(d == f);
            }

            {
               Data d;
               const char* f = "asdasd";
               d = f;
               assert(d == f);
            }

            {
               Data d("asdfasfdsadf");
               const char* f = "asdasd";
               d = f;
               assert(d == f);
            }

            {
               const char* f = "asdasd";
               Data d = Data(f);
               assert(!(d < f));
            }

            {
               Data d;
               const char* f = "asdasd";
               d = f;
               assert(!(d < f));
            }

            {
               Data d("asdfasfdsadf");
               const char* f = "asdasd";
               d = f;
               assert(!(d < f));
            }

            {
               Data a("qwerty");
               Data b("qwerty");
               assert(!(a < b));
            }

            {
               Data a("qwert");
               Data b("qwerty");
               assert(a < b);
            }

            {
               Data a("qwert");
               Data b("qwerty");
               assert(a < b);
               assert(!(b < a));
            }

            {
               const char* f = "asdasda";
               Data d("asdasd");
               assert(d < f);
            }

            {
               const char * c("asdfasfdsadf");
               Data d(Data::Share, c, 4);
               assert(d < c);
            }

            {
               const char * c("asdfasfdsadf");
               Data d(Data::Share, c, strlen(c));
               assert(!(d < c));
            }

            {
               const char * c("asdfasfdsadf");
               Data d(Data::Share, c, strlen(c));
               assert(!(d < c));
               Data c1(d); // copy, null terminate
               assert(!(d < c1));
               assert(!(c1 < d));
            }

            {
               const char* f = "asdasd";
               Data d("fsadf");

               assert(!(d <= f));
            }

            {
               const Data f = "asdasd";
               Data d("fsadf");

               assert(!(d <= f));
            }

            {
               const char* f = "asdasd";
               Data d = Data(f);
               assert(d <= f);
            }

            {
               Data d;
               const char* f = "asdasd";
               d = f;
               assert(d <= f);
            }

            {
               Data d("asdfasfdsadf");
               const char* f = "asdasd";
               d = f;
               assert(d <= f);
            }
         
            {
               Data a("qwerty");
               Data b("qwerty");
               assert(a <= b);
            }
            {
               Data a("qwert");
               Data b("qwerty");
               assert(a <= b);
            }
            {
               Data a("qwert");
               Data b("qwerty");
               assert(a <= b);
               assert(!(b <= a));
            }

            {
               const char* f = "asdasda";
               Data d("asdasd");
               assert(d <= f);
            }

            {
               const char * c("asdfasfdsadf");
               Data d(Data::Share, c, 4);
               assert(d <= c);
            }

            {
               const char * c("asdfasfdsadf");
               Data d(Data::Share, c, strlen(c));
               assert(d <= c);
            }

            {
               const char * c("asdfasfdsadf");
               Data d(Data::Share, c, strlen(c));
               assert(d <= c);
               Data c1(d); // copy, null terminate
               assert(d <= c1);
               assert(c1 <= d);
            }
         }

         // test assignment
         {
            {
               Data d("sadfsa");
               d = "gasdfg";

               assert(d == "gasdfg");
            }

            {
               Data d;
               d = "gasdfg";

               assert(d == "gasdfg");
            }

            {
               Data d("sdfsdf");
               Data e(d);
               Data f("fsdgsdafg");
               Data g(f);

               e = g;
               assert(e == g);
            }
         }

         {
            // test resizing
            Data header(10, Data::Preallocate);
            assert(header.empty());

            header += 'c';
            header += " char";
            header += "acters";

            assert(header.size() > 10);
            cerr << header << endl;
            assert(header == "c characters");
         }

         {
            // test resizing
            Data header(10, Data::Preallocate);
            assert(header.empty());

            header += 'c';
            header += " char";
            header += Data("acters");

            assert(header.size() > 10);
            cerr << header << endl;
            assert(header == "c characters");
         }

         {
            // test resizing
            Data header(120, Data::Preallocate);
            assert(header.empty());

            header += 'c';
            header += " char";
            header += "acters";

            assert(header == "c characters");
         }

         {
            char *txt = "here is some text";
            Data notOwner(Data::Share, txt, strlen(txt));
            assert(notOwner.mMine == Data::Share);
            
            notOwner += " more text";
            assert(notOwner.mMine == Data::Take);
            assert(notOwner == "here is some text more text");
         }

         {
            char *txt = "here is some text";
            Data notOwner(Data::Share, txt, strlen(txt));
            assert(notOwner.mMine == Data::Share);
            
            notOwner += '!';
            assert(notOwner.mMine == Data::Take);
            assert(notOwner == "here is some text!");
         }

         {
            char *txt = "here is some text";
            Data notOwner(Data::Share, txt, strlen(txt));
            assert(notOwner.mMine == Data::Share);
            
            notOwner += Data(" more text");
            assert(notOwner.mMine == Data::Take);
            assert(notOwner == "here is some text more text");
         }

         {
            Data v("some text");
            assert(v.prefix("some"));
            assert(v.prefix("some "));
            assert(!v.prefix("ome "));
            assert(!v.prefix("some more text"));

            assert(v.prefix(Data::Empty));
            assert(v.prefix("some text"));
            assert(v.prefix(v));
            assert(!v.prefix("some text "));
         }

         {
            Data v("some text");
            assert(v.postfix("text"));
            assert(v.postfix(" text"));
            assert(!v.postfix("tex"));
            assert(!v.postfix("more some text"));

            assert(v.postfix(Data::Empty));
            assert(v.postfix("some text"));
            assert(v.postfix(v));
            assert(!v.postfix(" some text"));
         }

         {
            Data transport("transport");