testparsercategories.cxx

这是国外的resip协议栈

   
   {
      TR _tr("Testing qop stuff");
      char* authenticationString = "realm=\"66.100.107.120\", username=\"1234\", nonce=\"1011235448\"   , uri=\"sip:66.100.107.120\"   , algorithm=MD5, qop=\"auth,auth-int\"";
      char* authorizationString = "realm=\"66.100.107.120\", username=\"1234\", nonce=\"1011235448\"   , uri=\"sip:66.100.107.120\"   , algorithm=MD5, response=\"8a5165b024fda362ed9c1e29a7af0ef2\", qop=auth";
      HeaderFieldValue authenHfv(authenticationString, strlen(authenticationString));
      HeaderFieldValue authorHfv(authorizationString, strlen(authorizationString));
      
      Auth wwwAuthen(&authenHfv, Headers::WWWAuthenticate);
      Auth pAuthen(&authenHfv, Headers::ProxyAuthenticate);
      Auth authInfo(&authorHfv, Headers::AuthenticationInfo);
      Auth pAuthor(&authorHfv, Headers::ProxyAuthorization);
      Auth author(&authorHfv, Headers::Authorization);

      assert(wwwAuthen.exists(p_qopOptions));
      assert(!wwwAuthen.exists(p_qop));
      assert(wwwAuthen.param(p_qopOptions)=="auth,auth-int");
      
      assert(pAuthen.exists(p_qopOptions));
      assert(!pAuthen.exists(p_qop));
      assert(pAuthen.param(p_qopOptions)=="auth,auth-int");
      
      assert(!authInfo.exists(p_qopOptions));
      assert(authInfo.exists(p_qop));
      assert(authInfo.param(p_qop)=="auth");
      
      assert(!pAuthor.exists(p_qopOptions));
      assert(pAuthor.exists(p_qop));
      assert(pAuthor.param(p_qop)=="auth");
      
      assert(!author.exists(p_qopOptions));
      assert(author.exists(p_qop));
      assert(author.param(p_qop)=="auth");
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            wwwAuthen.encode(str);
         }
         assert(encoded.find("qop=auth")==Data::npos);
         assert(encoded.find("qop=\"auth,auth-int\"")!=Data::npos);
         assert(encoded.find("qop=\"auth\"")==Data::npos);
         assert(encoded.find("qop=auth,auth-int")==Data::npos);
      }
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            pAuthen.encode(str);
         }
         assert(encoded.find("qop=auth")==Data::npos);
         assert(encoded.find("qop=\"auth,auth-int\"")!=Data::npos);
         assert(encoded.find("qop=\"auth\"")==Data::npos);
         assert(encoded.find("qop=auth,auth-int")==Data::npos);
      }
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            authInfo.encode(str);
         }
         assert(encoded.find("qop=auth")!=Data::npos);
         assert(encoded.find("qop=\"auth,auth-int\"")==Data::npos);
         assert(encoded.find("qop=\"auth\"")==Data::npos);
         assert(encoded.find("qop=auth,auth-int")==Data::npos);
      }
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            pAuthor.encode(str);
         }
         assert(encoded.find("qop=auth")!=Data::npos);
         assert(encoded.find("qop=\"auth,auth-int\"")==Data::npos);
         assert(encoded.find("qop=\"auth\"")==Data::npos);
         assert(encoded.find("qop=auth,auth-int")==Data::npos);
      }
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            author.encode(str);
         }
         assert(encoded.find("qop=auth")!=Data::npos);
         assert(encoded.find("qop=\"auth,auth-int\"")==Data::npos);
         assert(encoded.find("qop=\"auth\"")==Data::npos);
         assert(encoded.find("qop=auth,auth-int")==Data::npos);
      }
      
      Auth emptyAuthor;
      Auth emptyAuthen;
      
      emptyAuthor.param(p_qop)="auth";
      emptyAuthen.param(p_qopOptions)="auth";
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            emptyAuthor.encode(str);
         }
         assert(encoded.find("qop=auth")!=Data::npos);
         assert(encoded.find("qop=\"auth\"")==Data::npos);
      }
      
      {
         Data encoded;
         {
            oDataStream str(encoded);
            emptyAuthen.encode(str);
         }
         assert(encoded.find("qop=auth")==Data::npos);
         assert(encoded.find("qop=\"auth\"")!=Data::npos);
      }
   }

   {
      TR _tr("More Auth Encoding");

      Auth auth;
      Auth auth2;
      auth.scheme() = "Digest";
      auth.param(p_username) = "bob";

      auth2 = auth;
      Auth auth3(auth2);
      
      Data a;
      Data a1;
      Data a2;
      {
         DataStream s(a);
         s << auth;
      }
      {
         DataStream s(a1);
         s << auth;
      }
      {
         DataStream s(a2);
         s << auth;
      }
      
      assert(a == a1);
      assert(a1 == a2);
   }

   {
      TR _tr("Generic URI stuff");

      char* genericString = "<http://www.google.com>;purpose=icon;fake=true";
      HeaderFieldValue hfv(genericString, strlen(genericString));

      GenericUri generic(&hfv, Headers::UNKNOWN);

      assert(generic.uri() == "http://www.google.com");
      cerr << generic.param(p_purpose) << endl;
      assert(generic.param(p_purpose) == "icon");
      assert(generic.param(UnknownParameterType("fake")) == "true");

      stringstream s;
      generic.encode(s);

      cerr << s.str() << endl;
      
      assert(s.str() == "<http://www.google.com>;purpose=icon;fake=true");
   }

   {
      TR _tr("Date testing 1");
      char *dateString = "Mon, 04 Nov 2002 17:34:15 GMT";
      HeaderFieldValue hfv(dateString, strlen(dateString));
      
      DateCategory date(&hfv, Headers::UNKNOWN);

      assert(date.dayOfWeek() == Mon);
      assert(date.dayOfMonth() == 04);
      assert(date.month() == Nov);
      assert(date.year() == 2002);
      assert(date.hour() == 17);
      assert(date.minute() == 34);
      assert(date.second() == 15);

      stringstream s;
      date.encode(s);

      cerr << s.str() << endl;

      assert(s.str() == dateString);
      
      // copy ctor  not working in v1.94 ParserCategories.cxx
      
      stringstream s2;
      DateCategory otherDate(date);
      otherDate.encode(s2);
      cerr << "!! original date     : " << date << endl;
      cerr << "!! original string   : " << dateString << endl;
      cerr << "!! otherDate         : " << otherDate << endl;
      cerr << "!! encoded otherDate : " <<  s2.str() << endl;
      assert (s2.str() == dateString);

   }

   {
      TR _tr("Date testing 2");
      char *dateString = "  Sun  , 14    Jan 2222 07:04:05   GMT    ";
      HeaderFieldValue hfv(dateString, strlen(dateString));
      
      DateCategory date(&hfv, Headers::UNKNOWN);

      assert(date.dayOfWeek() == Sun);
      assert(date.dayOfMonth() == 14);
      assert(date.month() == Jan);
      assert(date.year() == 2222);
      assert(date.hour() == 07);
      assert(date.minute() == 04);
      assert(date.second() == 05);

      stringstream s;
      date.encode(s);
      assert(s.str() == "Sun, 14 Jan 2222 07:04:05 GMT");
   }


   {
      TR _tr("Mime types 1");

      char* mimeString = "application/sdp";
      HeaderFieldValue hfv(mimeString, strlen(mimeString));
      
      Mime mime(&hfv, Headers::UNKNOWN);

      assert(mime.type() == "application");
      assert(mime.subType() == "sdp");

      stringstream s;
      mime.encode(s);
      assert(s.str() == mimeString);
   }


   {
      TR _tr("Mime types 2");
      char* mimeString = "text/html ; charset=ISO-8859-4";
      HeaderFieldValue hfv(mimeString, strlen(mimeString));
      
      Mime mime(&hfv, Headers::UNKNOWN);

      assert(mime.type() == "text");
      assert(mime.subType() == "html");
      assert(mime.param(p_charset) == "ISO-8859-4");

      stringstream s;
      mime.encode(s);
      assert(s.str() == "text/html;charset=ISO-8859-4");
   }

   {
      TR _tr("Mime types 3");

      char* mimeString = "    text   /     html        ;  charset=ISO-8859-4";
      HeaderFieldValue hfv(mimeString, strlen(mimeString));
      
      Mime mime(&hfv, Headers::UNKNOWN);

      assert(mime.type() == "text");
      assert(mime.subType() == "html");
      assert(mime.param(p_charset) == "ISO-8859-4");

      stringstream s;
      mime.encode(s);
      assert(s.str() == "text/html;charset=ISO-8859-4");
   }

   {
      TR _tr("Via 1");

      Via via;
      via.encode(cerr);
      cerr << endl;

      assert (via.param(p_branch).hasMagicCookie());
   }

   {
      TR _tr("Via 2");
      
      char* viaString = "SIP/2.0/UDP ;branch=z9hG4bKwkl3lkjsdfjklsdjklfdsjlkdklj";
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      
      assert (via.param(p_branch).hasMagicCookie());

      stringstream s0;
      via.encode(s0);
      cerr << s0.str() << endl;
      assert(s0.str() == "SIP/2.0/UDP ;branch=z9hG4bKwkl3lkjsdfjklsdjklfdsjlkdklj");
      
      assert (via.param(p_branch).getTransactionId() == "wkl3lkjsdfjklsdjklfdsjlkdklj");
      
      stringstream s1;
      via.encode(s1);
      assert(s1.str() == "SIP/2.0/UDP ;branch=z9hG4bKwkl3lkjsdfjklsdjklfdsjlkdklj");
      
      via.param(p_branch).reset("jason");
      stringstream s2;
      via.encode(s2);
      cerr << "!! " << s2.str() << endl;
      assert(s2.str() == "SIP/2.0/UDP ;branch=z9hG4bK" RESIP_COOKIE "jason-1--" RESIP_COOKIE "");
      assert(via.param(p_branch).getTransactionId() == "jason");
   }

   {
      TR _tr("Via 3");
      char* viaString = "SIP/2.0/UDP ;branch=z9hG4bKwkl3lkjsdfjklsdjklfdsjlkdklj ;ttl=70";
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      
      assert (via.param(p_branch).hasMagicCookie());
      assert (via.param(p_branch).getTransactionId() == "wkl3lkjsdfjklsdjklfdsjlkdklj");
      assert (via.param(p_ttl) == 70);
   }

   {
      TR _tr("Via 4");
      char* viaString = "SIP/2.0/UDP ;branch=oldassbranch";
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      
      assert (!via.param(p_branch).hasMagicCookie());
      assert (via.param(p_branch).getTransactionId() == "oldassbranch");
      
      stringstream s;
      via.encode(s);
      assert(s.str() == "SIP/2.0/UDP ;branch=oldassbranch");
      
      via.param(p_branch).reset("jason");
      stringstream s2;
      via.encode(s2);
      assert(s2.str() == "SIP/2.0/UDP ;branch=z9hG4bK" RESIP_COOKIE "jason-1--" RESIP_COOKIE "");
      assert(via.param(p_branch).getTransactionId() == "jason");
   }

   {
      TR _tr("Via 5 assignment with unknown parameter");
      char* viaString = "SIP/2.0/UDP ;branch=z9hG4bKwkl3lkjsdfjklsdjklfdsjlkdklj ;ttl=70;stid=abcd.2";
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      
      assert (via.param(p_branch).hasMagicCookie());
      assert (via.param(p_branch).getTransactionId() == "wkl3lkjsdfjklsdjklfdsjlkdklj");
      assert (via.param(p_ttl) == 70);

      Via via1;
      via1 = via;

      cerr << "!! "; via1.encode(cerr); cerr << endl;
      assert(via1.param(UnknownParameterType("stid")) == "abcd.2");
   }

   {
      TR _tr("Via 6 parse with known parameter");
      char* viaString = "SIP/2.0/UDP whistler.gloo.net:5061;branch=z9hG4bK" RESIP_COOKIE "ec1e.0-1--" RESIP_COOKIE ";ttl=4\r\n";
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      
      assert (via.param(p_branch).hasMagicCookie());
      assert (via.param(p_branch).getTransactionId() == "ec1e.0");
      cerr << "!! "; via.encode(cerr); cerr << endl;
      assert(via.param(p_ttl) == 4);
   }

   {
      TR _tr("Via 7 parse with unknown parameter");
      char* viaString = "SIP/2.0/UDP whistler.gloo.net:5061;branch=z9hG4bK" RESIP_COOKIE "ec1e.0-1--" RESIP_COOKIE ";stid=489573115\r\n";
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      
      assert (via.param(p_branch).hasMagicCookie());
      assert (via.param(p_branch).getTransactionId() == "ec1e.0");
      cerr << "!! "; via.encode(cerr); cerr << endl;
      assert(via.param(UnknownParameterType("stid")) == "489573115");
   }

   {
      TR _tr("Branch parameter 1");
      
      Data txt("=z9hG4bK" RESIP_COOKIE "jason-1--" RESIP_COOKIE "");
      ParseBuffer pb(txt.data(), txt.size());
      BranchParameter bp(ParameterTypes::branch, pb, ";");
      assert(bp.hasMagicCookie());
      assert(bp.getTransactionId() == "jason");

      bp.reset(bp.getTransactionId() + ".10");
      bp.encode(cerr); cerr << endl;
      assert(bp.getTransactionId() == "jason.10");

      Data o;
      {
         DataStream s(o);
         bp.encode(s);
      }
      cerr << "!! " << o << endl;
      assert(o == "branch=z9hG4bK" RESIP_COOKIE "jason.10-1--" RESIP_COOKIE "");
   }

      
   {
      TR _tr("Branch parameter 2");
      Data txt("=z9hG4bK" RESIP_COOKIE "jason.1.2.3-14--" RESIP_COOKIE "");