testparsercategories.cxx

一个著名的SIP协议栈

   {
      TR _tr( "Test StringCategory");
      Data stringString("Lame Agent");
      HeaderFieldValue hfv(stringString.data(), stringString.size());
      
      StringCategory str(&hfv, Headers::UNKNOWN);
      assert(str.value() == stringString);

      Data buff;
      {
         DataStream s(buff);
         str.encode(s);
      }
      cerr << buff << endl;
      assert(buff == stringString);

      StringCategory copy(str);
      assert(copy.value() == stringString);

      str.value() = "foo";
      assert(str.value() == "foo");
   }

   {
      TR _tr( "Test Token parameters");
      Token state;
      state.value() = Data("active");
      state.param(p_expires) = 666;
      cerr << state << endl;
   }

   {
      TR _tr( "StatusLine, with reason code");
      Data statusLineString("SIP/2.0 180 Ringing");
      HeaderFieldValue hfv(statusLineString.data(), statusLineString.size());
      
      StatusLine statusLine(&hfv, Headers::UNKNOWN);
      assert(statusLine.responseCode() == 180);
      cerr << statusLine.reason() << endl;
      assert(statusLine.reason() == "Ringing");
      assert(statusLine.getSipVersion() == "SIP/2.0");

      StatusLine copy(statusLine);
      assert(copy.responseCode() == 180);
      assert(copy.reason() == "Ringing");
      assert(copy.getSipVersion() == "SIP/2.0");
   }
   {
      Uri foo;
      // valgrind complains, but the problem moves when closely observed
      assert(foo.getAor().empty());
   }

#define checkHeaderName(_name) cerr << Headers::_name << " " << Headers::getHeaderName(Headers::_name) << " = " << #_name << endl /*;assert(isEqualNoCase(Headers::getHeaderName(Headers::_name), #_name))*/
   {
      // test header hash
      for (int i = Headers::CSeq; i < Headers::MAX_HEADERS; i++)
      {
         if (i == Headers::RESIP_DO_NOT_USE)
         {
            continue;
         }
         
         Data hdr = Headers::getHeaderName(i);
         if (!hdr.size()) continue;
         Data msg("Checking hash of: ");
         msg += hdr;
         TR _tr(msg);
         assert(Headers::getType(Headers::getHeaderName(i).c_str(), Headers::getHeaderName(i).size()) == i);
      }
      checkHeaderName(To);
      checkHeaderName(From);
      checkHeaderName(Via);
      checkHeaderName(CallID);
      checkHeaderName(CSeq);
      checkHeaderName(Route);
      checkHeaderName(RecordRoute);
      checkHeaderName(Contact);
      checkHeaderName(Subject);
      checkHeaderName(Expires);
      checkHeaderName(MaxForwards);
      checkHeaderName(Accept);
      checkHeaderName(AcceptEncoding);
      checkHeaderName(AcceptLanguage);
      checkHeaderName(AlertInfo);
      checkHeaderName(Allow);
      checkHeaderName(AuthenticationInfo);
      checkHeaderName(CallInfo);
      checkHeaderName(ContentDisposition);
      checkHeaderName(ContentEncoding);
      checkHeaderName(ContentLanguage);
      checkHeaderName(ContentTransferEncoding);
      checkHeaderName(ContentType);
      checkHeaderName(Date);
      checkHeaderName(InReplyTo);
      checkHeaderName(MinExpires);
      checkHeaderName(MIMEVersion);
      checkHeaderName(Organization);
      checkHeaderName(Priority);
      checkHeaderName(ProxyAuthenticate);
      checkHeaderName(ProxyAuthorization);
      checkHeaderName(ProxyRequire);
      checkHeaderName(ReplyTo);
      checkHeaderName(Require);
      checkHeaderName(RetryAfter);
      checkHeaderName(Server);
      checkHeaderName(SIPETag);
      checkHeaderName(SIPIfMatch);
      checkHeaderName(Supported);
      checkHeaderName(Timestamp);
      checkHeaderName(Unsupported);
      checkHeaderName(UserAgent);
      checkHeaderName(Warning);
      checkHeaderName(WWWAuthenticate);
      checkHeaderName(SubscriptionState);
      checkHeaderName(ReferTo);
      checkHeaderName(ReferredBy);
      checkHeaderName(Authorization);
      checkHeaderName(Replaces);
      checkHeaderName(Event);
      checkHeaderName(AllowEvents);
      checkHeaderName(SecurityClient);
      checkHeaderName(SecurityServer);
      checkHeaderName(SecurityVerify);
      checkHeaderName(ContentLength);
      checkHeaderName(ContentId);

   }

#define checkParameterName(_name) cerr << ParameterTypes::_name << " " << ParameterTypes::ParameterNames[ParameterTypes::_name] << " = " << #_name << endl/*;assert(isEqualNoCase(ParameterTypes::ParameterNames[ParameterTypes::_name], #_name))*/
   {
      checkParameterName(data);
      checkParameterName(control);
      checkParameterName(mobility);
      checkParameterName(description);
      checkParameterName(events);
      checkParameterName(priority);
      checkParameterName(methods);
      checkParameterName(schemes);
      checkParameterName(application);
      checkParameterName(video);
      checkParameterName(language);
      checkParameterName(type);
      checkParameterName(isFocus);
      checkParameterName(actor);
      checkParameterName(text);
      checkParameterName(extensions);
      checkParameterName(Instance);
      checkParameterName(gruu);

      checkParameterName(transport);
      checkParameterName(user);
      checkParameterName(method);
      checkParameterName(ttl);
      checkParameterName(maddr);
      checkParameterName(lr);
      checkParameterName(q);
      checkParameterName(purpose);
      checkParameterName(expires);
      checkParameterName(handling);
      checkParameterName(tag);
      checkParameterName(toTag);
      checkParameterName(fromTag);
      checkParameterName(duration);
      checkParameterName(branch);
      checkParameterName(received);
      checkParameterName(comp);
      checkParameterName(rport);
      checkParameterName(algorithm);
      checkParameterName(cnonce);
      checkParameterName(domain);
      checkParameterName(id);
      checkParameterName(nonce);
      checkParameterName(nc);
      checkParameterName(opaque);
      checkParameterName(realm);
      checkParameterName(response);
      checkParameterName(stale);
      checkParameterName(username);
      checkParameterName(qop);
      checkParameterName(uri);
      checkParameterName(retryAfter);
      checkParameterName(reason);
      checkParameterName(dAlg);
      checkParameterName(dQop);
      checkParameterName(dVer);
      checkParameterName(smimeType);
      checkParameterName(name);
      checkParameterName(filename);
      checkParameterName(protocol);
      checkParameterName(micalg);
      checkParameterName(boundary);
      checkParameterName(expiration);
      checkParameterName(size);
      checkParameterName(permission);
      checkParameterName(site);
      checkParameterName(directory);
      checkParameterName(mode);
      checkParameterName(server);
      checkParameterName(charset);
      checkParameterName(accessType);
      checkParameterName(profileType);
      checkParameterName(vendor);
      checkParameterName(model);
      checkParameterName(version);
      checkParameterName(effectiveBy);
      checkParameterName(document);
      checkParameterName(appId);
      checkParameterName(networkUser);
      
      checkParameterName(url);
      


      // test parameter hash
      for (int i = 0; i < ParameterTypes::MAX_PARAMETER; i++)
      {
         if (i != ParameterTypes::qopOptions &&
             i != ParameterTypes::qop &&
             i != ParameterTypes::qopFactory)
         {
	    
            TR _tr( Data("Checking hash of: ") +  Data(ParameterTypes::ParameterNames[i]));
            assert(ParameterTypes::getType(ParameterTypes::ParameterNames[i].c_str(), 
                                           ParameterTypes::ParameterNames[i].size()) == i);
         }
      }

      assert(ParameterTypes::ParameterNames[ParameterTypes::qop] == "qop");
      assert(ParameterTypes::ParameterNames[ParameterTypes::qopOptions] == "qop");
      assert(ParameterTypes::getType("qop", 3) == ParameterTypes::qopFactory);
   }
   
   {
      TR _tr( "simple Token parse test");
      char *org = "WuggaWuggaFoo";
      
      HeaderFieldValue hfv(org, strlen(org));
      Token tok(&hfv, Headers::UNKNOWN);
      assert(tok.value() == org);
   }

   {
      TR _tr( "Token + parameters parse test");
      char *org = "WuggaWuggaFoo;ttl=2";
      
      HeaderFieldValue hfv(org, strlen(org));
      Token tok(&hfv, Headers::UNKNOWN);
      assert(tok.value() == "WuggaWuggaFoo");
      assert(tok.param(p_ttl) == 2);
   }

   {
      TR _tr( "Test NameAddr(Data) constructor");
      
      Data nad("bob<sips:[e-mail]>;tag=wd834f");
      NameAddr na(nad); 
      assert(na.uri().user() == "bob");
   }

   {
      TR _tr( "full on via parse");
      char *viaString = /* Via: */ " SIP/2.0/UDP a.b.c.com:5000;ttl=3;maddr=1.2.3.4;received=foo.com";
      
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      assert(via.sentPort() == 5000);
      assert(via.sentHost() == "a.b.c.com");
      assert(via.param(p_maddr) == "1.2.3.4");
   }

   {
      TR _tr("Test poorly formed DataParameter by construction");

      char *viaString = /* Via: */ " SIP/2.0/UDP example.com:5000;;tag=";
      
      HeaderFieldValue hfv(viaString, strlen(viaString));
      try
      {
         Via via(&hfv, Headers::UNKNOWN);
         via.sentPort();
         assert(false);
      }
      catch (ParseBuffer::Exception& e)
      {
         cerr << "Caught parse exception for Via" << endl;
      }
   }

   {
      TR _tr("Test poorly formed UnknownParameter by construction");

      char *viaString = /* Via: */ " SIP/2.0/UDP example.com:5000;;foobar=";
      
      HeaderFieldValue hfv(viaString, strlen(viaString));
      try
      {
         Via via(&hfv, Headers::UNKNOWN);
         via.sentPort();
         UnknownParameterType p_foobar("foobar");
         via.exists(p_foobar);
         assert(false);
      }
      catch (ParseBuffer::Exception& e)
      {
         cerr << "Caught parse exception for Via" << endl;
      }
   }

   {
      TR _tr("Test poorly formed UInt32Parameter by construction");

      char *viaString = /* Via: */ " SIP/2.0/UDP example.com:5000;;duration=";
      
      HeaderFieldValue hfv(viaString, strlen(viaString));
      try
      {
         Via via(&hfv, Headers::UNKNOWN);
         via.sentPort();
         assert(false);
      }
      catch (ParseBuffer::Exception& e)
      {
         cerr << "Caught parse exception for Via " << endl;
      }
   }

   {
      TR _tr("Test poorly formed QuotedDataParameter by construction");

      char *viaString = /* Via: */ " SIP/2.0/UDP example.com:5000;;domain=\"";
      
      HeaderFieldValue hfv(viaString, strlen(viaString));
      try
      {
         Via via(&hfv, Headers::UNKNOWN);
         via.sentPort();
         assert(false);
      }
      catch (ParseBuffer::Exception& e)
      {
         cerr << "Caught parse exception for Via " << endl;
      }
   }

#ifdef USE_IPV6
   {
      TR _tr( "full on via parse, IPV6");
      // !dlb! deal with maddr=[5f1b:df00:ce3e:e200:20:800:2b37:6426]
      char *viaString = /* Via: */ " SIP/2.0/UDP [5f1b:df00:ce3e:e200:20:800:2b37:6426]:5000;ttl=3;maddr=1.2.3.4;received=foo.com";
      
      HeaderFieldValue hfv(viaString, strlen(viaString));
      Via via(&hfv, Headers::UNKNOWN);
      assert(via.sentPort() == 5000);
      assert(via.sentHost() == "5f1b:df00:ce3e:e200:20:800:2b37:6426");
      assert(via.param(p_maddr) == "1.2.3.4");
   }
#endif
   {
      TR _tr( "URI parse");
      Data uriString = "sip:[e-mail]";
      ParseBuffer pb(uriString.data(), uriString.size());
      NameAddr to;
      to.parse(pb);
      Uri& uri = to.uri();
      cerr << "!! " << to << endl;
      assert(uri.scheme() == "sip");
      assert(uri.user() == "bob");
      assert(uri.host() == "foo.com");
      assert(uri.port() == 0);
   }

   {
      TR _tr( "URI parse, no displayName");
      Data uriString = "sips:foo.com";
      ParseBuffer pb(uriString.data(), uriString.size());
      NameAddr to;
      to.parse(pb);
      Uri& uri = to.uri();
      assert(uri.scheme() == "sips");
      assert(uri.user() == "");
      assert(uri.host() == "foo.com");
      assert(uri.port() == 0);
   }

   {
      TR _tr( "URI parse, parameters");
      Data uriString = "sips:bob;param=gargle:[e-mail]";
      ParseBuffer pb(uriString.data(), uriString.size());