testparsercategories.cxx

这是国外的resip协议栈

#include <assert.h>
#include <iostream>
#include <sstream>
#include <string.h>
#include <string>
#include "resip/stack/HeaderFieldValue.hxx"
#include "resip/stack/HeaderTypes.hxx"
#include "resip/stack/Headers.hxx"
#include "resip/stack/ParserCategories.hxx"
#include "resip/stack/ExtensionHeader.hxx"
#include "resip/stack/UnknownParameterType.hxx"
#include "resip/stack/ApiCheckList.hxx"
#include "resip/stack/Uri.hxx"
#include "rutil/DataStream.hxx"
#include "rutil/ParseBuffer.hxx"
#include "rutil/Logger.hxx"

using namespace std;
using namespace resip;

#define RESIPROCATE_SUBSYSTEM Subsystem::TEST
#define RESIP_COOKIE "-d8754z-"

class TR
{
   private:
      ostream& os;
      Data label;

      TR(const TR&);

      void show(const char * s)
      {
         os << s << ' ' << label << endl;
      }

      void start()
      {
         show("-->");
      }
      
      void end()
      {
         show("<--");
      }
      
   public:
      TR(Data  s,ostream& o = cerr ):os(o),label(s) { start(); }
      TR(const char* l,ostream& o = cerr):os(o),label(l) { start(); }
      ~TR() { end();}
};

int
main(int arc, char** argv)
{
   Log::initialize(Log::Cout, Log::Debug, argv[0]);



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

      try
      {
         NameAddr test("<jason_AT_example.com@10.0.0.1;transport=TCP>");
         assert(false);
      }
      catch (ParseException& e)
      {
         cerr << e << endl;
      }
   }
   
   {
      TR _tr("Test copy transport param");

      NameAddr test("<sip:jason_AT_example.com@10.0.0.1:5060;transport=TCP>");
      cerr << test << endl;
      NameAddr copy = test;
      cerr << copy << endl;
      assert(test.uri().exists(p_transport));
      assert(copy.uri().exists(p_transport));
      
      assert(test.uri().param(p_transport) == copy.uri().param(p_transport));
   }
   
   {
      TR _tr("Test iterator erase in ParserContainer");

      NameAddrs nameAddrs;

      nameAddrs.push_back(NameAddr(Uri("sip:[e-mail]")));
      nameAddrs.push_back(NameAddr(Uri("sip:[e-mail]")));
      nameAddrs.push_back(NameAddr(Uri("sip:[e-mail]")));
      nameAddrs.push_back(NameAddr(Uri("sip:[e-mail]")));

      assert(nameAddrs.size() == 4);

      NameAddrs::iterator i = nameAddrs.begin();
      ++i;

      nameAddrs.erase(i);

      assert(nameAddrs.size() == 3);

      nameAddrs.erase(nameAddrs.begin());
      assert(nameAddrs.size() == 2);

      assert(nameAddrs.begin()->uri().user() == "third");
   }

   {
      TR _tr("Test find in ParserContainer");

      Tokens tokens;

      tokens.push_back(Token("Foo"));
      tokens.push_back(Token("Bar"));
      tokens.push_back(Token("Baz"));
      tokens.push_back(Token("Quux"));

      assert(tokens.find(Token("Foo")));
      assert(tokens.find(Token("Bar")));
      assert(tokens.find(Token("Baz")));
      assert(tokens.find(Token("Quux")));

      assert(!tokens.find(Token("Zab")));
   }

   {
      TR _tr("Test remove parameters that appear multiple times");
      Uri uri1("sip:a@b;xtype=1;maddr=local;xtype=2;maddr=remote;xtype=3;maddr=other");
      Uri uri2(uri1);

      uri1.remove(p_maddr);
      Data res1;
      {
         DataStream str(res1);
         str << uri1;
      }
      assert(res1 == "sip:a@b;xtype=1;xtype=2;xtype=3");

      UnknownParameterType p_xtype("xtype");
      uri2.remove(p_xtype);
      Data res2;
      {
         DataStream str(res2);
         str << uri2;
      }   
      assert(res2 == "sip:a@b;maddr=local;maddr=remote;maddr=other");
   }
   
   {
         {
            TR _tr("Test remove parameters that appear multiple times");
            Uri uri1("sips:[e-mail];transport=udp");
            Uri aor = uri1.getAorAsUri();

            Data res;
            {
               DataStream str(res);
               str << aor;
            }   
            cerr << res << endl;
            
            assert(res == "sips:[e-mail]");
         }
         
   }


   {
      TR _tr("Test remove parameters that appear multiple times; mixed predefined and extensions");
      Uri uri1("sip:a@b;xtype=1;maddr=local;foo=bar;ttl=17;xtype=2;maddr=remote;foo=baz;ttl=42;xtype=3;maddr=other;foo=foo;ttl=111");
      Uri uri2(uri1);

      uri1.remove(p_maddr);
      Data res1;
      {
         DataStream str(res1);
         str << uri1;
      }
      assert(res1 == "sip:a@b;ttl=17;ttl=42;ttl=111;xtype=1;foo=bar;xtype=2;foo=baz;xtype=3;foo=foo");

      UnknownParameterType p_xtype("xtype");
      uri2.remove(p_xtype);
      Data res2;
      {
         DataStream str(res2);
         str << uri2;
      }   
      assert(res2 == "sip:a@b;maddr=local;ttl=17;maddr=remote;ttl=42;maddr=other;ttl=111;foo=bar;foo=baz;foo=foo");
   }

   {
      TR _tr("Test exists unknown parameter");

      Uri uri1("sip:a@b;xaudio");
      assert(uri1.exists(UnknownParameterType("xaudio")));
      assert(uri1.param(UnknownParameterType("xaudio")) == Data::Empty);
      
      Uri uri2("sip:a@b;a=b;xaudio");
      cerr << uri2.param(UnknownParameterType("a")) << endl;
      
      assert(uri2.exists(UnknownParameterType("xaudio")));
      assert(uri2.param(UnknownParameterType("xaudio")) == Data::Empty);

      Uri uri3("sip:a@b;xaudio;a=b");
      assert(uri3.exists(UnknownParameterType("xaudio")));
      assert(uri3.param(UnknownParameterType("xaudio")) == Data::Empty);
   }

   {
      TR _tr("Test non-quoted tokens displayname in NameAddr (torture test: 2.39)");
      Data data("A. Bell <sip:[e-mail]>;tag=459843");

      NameAddr legal(data);

      assert(legal.uri().host() == "bell-tel.com");

      cerr << "!!" << legal << endl;

      assert(legal.displayName() == "A. Bell");
   }

   {
      TR _tr("Test quoted displayname in NameAddr (torture test: 2.39)");
      Data data("\"A. Bell\" <sip:[e-mail]>;tag=459843");

      NameAddr legal(data);

      assert(legal.uri().host() == "bell-tel.com");

      cerr << "!!" << legal.displayName() << endl;

      assert(legal.displayName() == "A. Bell");
   }

   {
      TR _tr("Test NameAddr parameter handling");
      Data data("sip:[e-mail];user=phone");
      
      NameAddr original(data);
      assert(original.uri().exists(p_user));
      
      cerr << "!!" << original << endl;
   }

   {
      TR _tr("Test tel aor canonicalization");
      Data data("tel:[phone];pOstd=pP2;isUb=1411");
      
      Uri original(data);
      cerr << original.getAor() << endl;
      
      assert(original.getAor() == "[phone]");
   }

   {
      TR _tr("Test aor canonicalization");
      Data data("sip:[e-mail]:5666");
      Data data1("sip:[e-mail]:5666");
      
      Uri original(data);
      Uri original1(data1);

      cerr << "!! " << original.getAor() << " " << original1.getAor() << endl;
      assert(original.getAor() == original1.getAor());
   }

   {
      TR _tr("Test tel NameAddr");
      NameAddr n1("<tel:[phone]>");
      cerr << n1.uri().user() << endl;
   }

#ifdef USE_IPV6
   {
      TR _tr("Test cleverly malformed V6 addr in Uri");
      char* buf="sip:foo@[:x]";
      HeaderFieldValue hfv(buf, strlen(buf));
      NameAddr nameaddr(&hfv, Headers::UNKNOWN);
      assert(!nameaddr.isWellFormed());
   }
#endif
   
   {
      TR _tr("Test empty NameAddr");
      NameAddr n1;
      NameAddr n2;
      assert (!(n1 < n2));
      assert (!(n2 < n1));
      assert (n1.uri().getAor() == n2.uri().getAor());
   }

   {
      TR _tr("Test NameAddr q value");

      NameAddr w("<sip:wombat@192.168.2.221:5062;transport=Udp>;expires=63;q=1");
#ifndef RESIP_FIXED_POINT
      assert(w.param(p_q) == 1.0);
#endif
      assert(w.param(p_q) == 1000);
      w.param(p_q) = 843;
      assert(w.param(p_q) <= 843);
#ifndef RESIP_FIXED_POINT
      assert(w.param(p_q) == 0.843);
      w.param(p_q) = 0.843;
      assert(w.param(p_q) == 843);
      assert(w.param(p_q) == 0.843);
      w.param(p_q) = 0.65;
      assert(w.param(p_q) == 650);
#endif
      w.param(p_q) = 0;
      assert(w.param(p_q) == 0);
   }
   
   {
      TR _tr("Test NameAddr comparison");

      NameAddr w1("<sip:wombat@192.168.2.221:5062;transport=Udp>;expires=63");
      NameAddr w2("<sip:wombat@192.168.2.221:5063;transport=Udp>;expires=66");
      assert(w1 < w2);
      assert (!(w2 < w1));
   }

   {
      TR _tr("Test parameter with spaces");
      Data txt("Digest username=\"Alice\", realm = \"atlanta.com\", nonce=\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\", reponse=\"YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY\"\r\n");
      HeaderFieldValue hfv(txt.data(), txt.size());
      Auth auth(&hfv, Headers::Authorization);
      
      assert(auth.scheme() == "Digest");
      assert(auth.exists(p_realm));
   }

   {
      TR _tr("Test uri with no user");
      Data data("sip:kelowna.gloo.net");
      
      Uri original(data);
      cerr << original << endl;
      
      assert(Data::from(original) == data);
   }

   {
      TR _tr("Test assignment for NameAddr");
      NameAddr original(Data("\"Original\"<sip:[e-mail]>;tag=original"));
      (void)original.exists(p_tag);
      // force parse
      NameAddr newna(Data("\"new\"<sip:[e-mail]>;tag=new"));
      (void)newna.exists(p_tag);
      cout << "original NameAddr: ->" << original << "<-"<< endl;
      cout << "new NameAddr     : ->" << newna << "<-" << endl;
      original = newna;
      cout << "original : ->" << original << "<-"<< endl;
      assert(Data::from(original) == Data::from(newna));
   }
   {
      TR _tr("Test typeless parameter copy");
      Token s = Token("jason");
      s.value() = "value";
      s.param(p_expires) = 17;
      s.param(p_lr);
      s.param(UnknownParameterType("foobie")) = "quux";

      Token s1;
      s1.value() = "other";
      s1.param(p_ttl) = 21;

      s.setParameter(s1.getParameterByEnum(ParameterTypes::ttl));
      assert(s.value() == "value");
      assert(s.param(p_ttl) == 21);
      assert(s.param(p_lr));
      assert(s.param(UnknownParameterType("foobie")) == "quux");
   }

   {
      TR a("Test typeless parameter overwrite" );
      Token s;
      s.value() = "value";
      s.param(p_expires) = 17;
      s.param(p_ttl) = 12;
      s.param(p_lr);
      s.param(UnknownParameterType("foobie")) = "quux";

      Token s1;
      s1.value() = "other";
      s1.param(p_ttl) = 21;

      s.setParameter(s1.getParameterByEnum(ParameterTypes::ttl));
      assert(s.value() == "value");
      assert(s.param(p_ttl) == 21);
      assert(s.param(p_lr));
      assert(s.param(UnknownParameterType("foobie")) == "quux");

      s.encode(cerr);
      cerr << endl;
   }

   {
      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;