session_unittest.cc

本人收集整理的一份c/c++跨平台网络库

    int result = channel->SendPacket(data, size);
    ASSERT(result == static_cast<int>(size));
  }

  TransportChannel* channel;
  bool last_readable, last_writable;
  int data_count;
  char last_data[4096];
  size_t last_size;
};

char* Reverse(const char* str) {
  int len = strlen(str);
  char* rev = new char[len+1];
  for (int i = 0; i < len; i++)
    rev[i] = str[len-i-1];
  rev[len] = '\0';
  return rev;
}

// Sets up values that should be the same for every test.
void InitTest() {
  SetRandomSeed(7);
  gPort = 28653;
  gID = 0;
}

// Tests having client2 accept the session.
void TestAccept(talk_base::Thread* signaling_thread,
                Session* session1, Session* session2,
                SessionHandler* handler1, SessionHandler* handler2,
                SessionManager* manager1, SessionManager* manager2,
                SessionManagerHandler* manhandler1,
                SessionManagerHandler* manhandler2) {
  // Make sure the IQ ID is 5.
  ASSERT(gID <= 5);
  while (gID < 5) GetNextID();

  // Accept the session.
  SessionDescription* desc2 = new SessionDescription();
  bool valid = session2->Accept(desc2);
  ASSERT(valid);

  scoped_ptr<buzz::XmlElement> stanza;
  stanza.reset(manhandler2->CheckNextStanza(
    "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"5\""
    " xmlns:cli=\"jabber:client\">"
    "<session xmlns=\"http://www.google.com/session\" type=\"accept\""
    " id=\"2154761789\" initiator=\"[e-mail]\">"
    "<ses:description xmlns:ses=\"http://oink.splat/session\"/>"
    "</session>"
    "</cli:iq>"));
  manhandler2->CheckNoStanza();

  // Simulate a tiny delay in sending.
  signaling_thread->ProcessMessages(10);

  // Delivery the accept.
  manager1->OnIncomingMessage(stanza.get());
  stanza.reset(manhandler1->CheckNextStanza(
    "<cli:iq to=\"[e-mail]\" id=\"5\" type=\"result\" from=\"[e-mail]\""
    " xmlns:cli=\"jabber:client\"/>"));
  manhandler1->CheckNoStanza();

  // Both sessions should be in progress after a short wait.
  signaling_thread->ProcessMessages(10);
  ASSERT(handler1->last_state == Session::STATE_INPROGRESS);
  ASSERT(handler2->last_state == Session::STATE_INPROGRESS);
}

// Tests sending data between two clients, over two channels.
void TestSendRecv(ChannelHandler* chanhandler1a, ChannelHandler* chanhandler1b,
                  ChannelHandler* chanhandler2a, ChannelHandler* chanhandler2b,
                  talk_base::Thread* signaling_thread, bool first_dropped) {
  const char* dat1a = "spamspamspamspamspamspamspambakedbeansspam";
  const char* dat1b = "Lobster Thermidor a Crevette with a mornay sauce...";
  const char* dat2a = Reverse(dat1a);
  const char* dat2b = Reverse(dat1b);

  // Sending from 2 -> 1 will enable 1 to send to 2 below.  That will then
  // enable 2 to send back to 1.  So the code below will just work.
  if (first_dropped) {
    chanhandler2a->Send(dat2a, strlen(dat2a));
    chanhandler2b->Send(dat2b, strlen(dat2b));
  }

  for (int i = 0; i < 20; i++) {
    chanhandler1a->Send(dat1a, strlen(dat1a));
    chanhandler1b->Send(dat1b, strlen(dat1b));
    chanhandler2a->Send(dat2a, strlen(dat2a));
    chanhandler2b->Send(dat2b, strlen(dat2b));

    signaling_thread->ProcessMessages(10);

    ASSERT(chanhandler1a->data_count == i + 1);
    ASSERT(chanhandler1b->data_count == i + 1);
    ASSERT(chanhandler2a->data_count == i + 1);
    ASSERT(chanhandler2b->data_count == i + 1);

    ASSERT(chanhandler1a->last_size == strlen(dat2a));
    ASSERT(chanhandler1b->last_size == strlen(dat2b));
    ASSERT(chanhandler2a->last_size == strlen(dat1a));
    ASSERT(chanhandler2b->last_size == strlen(dat1b));

    ASSERT(std::memcmp(chanhandler1a->last_data, dat2a, strlen(dat2a)) == 0);
    ASSERT(std::memcmp(chanhandler1b->last_data, dat2b, strlen(dat2b)) == 0);
    ASSERT(std::memcmp(chanhandler2a->last_data, dat1a, strlen(dat1a)) == 0);
    ASSERT(std::memcmp(chanhandler2b->last_data, dat1b, strlen(dat1b)) == 0);
  }
}

// Tests a session between two clients.  The inputs indicate whether we should
// replace each client's output with what we would see from an old client.
void TestP2PCompatibility(const std::string& test_name, bool old1, bool old2) {
  InitTest();

  talk_base::Thread* signaling_thread = talk_base::Thread::Current();
  scoped_ptr<talk_base::Thread> worker_thread(new talk_base::Thread());
  worker_thread->Start();

  scoped_ptr<PortAllocator> allocator(
      new TestPortAllocator(worker_thread.get(), NULL));
  scoped_ptr<MySessionClient> client(new MySessionClient());
  client->SetTransports(true, false);

  scoped_ptr<SessionManager> manager1(
      new SessionManager(allocator.get(), worker_thread.get()));
  scoped_ptr<SessionManagerHandler> manhandler1(
      new SessionManagerHandler(manager1.get(), "[e-mail]"));
  client->AddManager(manager1.get());

  Session* session1 = manager1->CreateSession("[e-mail]", kSessionType);
  ASSERT(manhandler1->create_count == 1);
  ASSERT(manhandler1->last_id == session1->id());
  scoped_ptr<SessionHandler> handler1(new SessionHandler(session1));

  ASSERT(client->create_count == 1);
  TransportChannel* chan1a = client->a;
  ASSERT(chan1a->name() == "a");
  ASSERT(session1->GetChannel("a") == chan1a);
  scoped_ptr<ChannelHandler> chanhandler1a(new ChannelHandler(chan1a));
  TransportChannel* chan1b = client->b;
  ASSERT(chan1b->name() == "b");
  ASSERT(session1->GetChannel("b") == chan1b);
  scoped_ptr<ChannelHandler> chanhandler1b(new ChannelHandler(chan1b));

  SessionDescription* desc1 = new SessionDescription();
  ASSERT(session1->state() == Session::STATE_INIT);
  bool valid = session1->Initiate("[e-mail]", NULL, desc1);
  ASSERT(valid);
  handler1->PrepareTransport();

  signaling_thread->ProcessMessages(100);

  ASSERT(handler1->last_state == Session::STATE_SENTINITIATE);
  scoped_ptr<XmlElement> stanza1, stanza2;
  stanza1.reset(manhandler1->CheckNextStanza(
    "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"0\""
    " xmlns:cli=\"jabber:client\">"
    "<session xmlns=\"http://www.google.com/session\" type=\"initiate\""
    " id=\"2154761789\" initiator=\"[e-mail]\">"
    "<ses:description xmlns:ses=\"http://oink.splat/session\"/>"
    "<p:transport xmlns:p=\"http://www.google.com/transport/p2p\"/>"
    "</session>"
    "</cli:iq>"));
  stanza2.reset(manhandler1->CheckNextStanza(
    "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"1\""
    " xmlns:cli=\"jabber:client\">"
    "<session xmlns=\"http://www.google.com/session\" type=\"transport-info\""
    " id=\"2154761789\" initiator=\"[e-mail]\">"
    "<p:transport xmlns:p=\"http://www.google.com/transport/p2p\">"
    "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28653\""
    " preference=\"1\" username=\"h0ISP4S5SJKH/9EY\" protocol=\"udp\""
    " generation=\"0\" password=\"UhnAmO5C89dD2dZ+\" type=\"local\""
    " network=\"network\"/>"
    "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28658\""
    " preference=\"1\" username=\"yid4vfB3zXPvrRB9\" protocol=\"udp\""
    " generation=\"0\" password=\"SqLXTvcEyriIo+Mj\" type=\"local\""
    " network=\"network\"/>"
    "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28663\""
    " preference=\"1\" username=\"NvT78D7WxPWM1KL8\" protocol=\"udp\""
    " generation=\"0\" password=\"+mV/QhOapXu4caPX\" type=\"local\""
    " network=\"network\"/>"
    "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28668\""
    " preference=\"1\" username=\"8EzB7MH+TYpIlSp/\" protocol=\"udp\""
    " generation=\"0\" password=\"h+MelLXupoK5aYqC\" type=\"local\""
    " network=\"network\"/>"
    "</p:transport>"
    "</session>"
    "</cli:iq>"));
  manhandler1->CheckNoStanza();

  // If the first client were old, the initiate would have no transports and
  // the candidates would be sent in a candidates message.
  if (old1) {
    stanza1.reset(XmlElement::ForStr(
      "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"0\""
      " xmlns:cli=\"jabber:client\">"
      "<session xmlns=\"http://www.google.com/session\" type=\"initiate\""
      " id=\"2154761789\" initiator=\"[e-mail]\">"
      "<ses:description xmlns:ses=\"http://oink.splat/session\"/>"
      "</session>"
      "</cli:iq>"));
    stanza2.reset(XmlElement::ForStr(
      "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"1\""
      " xmlns:cli=\"jabber:client\">"
      "<session xmlns=\"http://www.google.com/session\" type=\"candidates\""
      " id=\"2154761789\" initiator=\"[e-mail]\">"
      "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28653\""
      " preference=\"1\" username=\"h0ISP4S5SJKH/9EY\" protocol=\"udp\""
      " generation=\"0\" password=\"UhnAmO5C89dD2dZ+\" type=\"local\""
      " network=\"network\"/>"
      "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28658\""
      " preference=\"1\" username=\"yid4vfB3zXPvrRB9\" protocol=\"udp\""
      " generation=\"0\" password=\"SqLXTvcEyriIo+Mj\" type=\"local\""
      " network=\"network\"/>"
      "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28663\""
      " preference=\"1\" username=\"NvT78D7WxPWM1KL8\" protocol=\"udp\""
      " generation=\"0\" password=\"+mV/QhOapXu4caPX\" type=\"local\""
      " network=\"network\"/>"
      "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28668\""
      " preference=\"1\" username=\"8EzB7MH+TYpIlSp/\" protocol=\"udp\""
      " generation=\"0\" password=\"h+MelLXupoK5aYqC\" type=\"local\""
      " network=\"network\"/>"
      "</session>"
      "</cli:iq>"));
  }

  scoped_ptr<SessionManager> manager2(
      new SessionManager(allocator.get(), worker_thread.get()));
  scoped_ptr<SessionManagerHandler> manhandler2(
      new SessionManagerHandler(manager2.get(), "[e-mail]"));
  client->AddManager(manager2.get());

  // Deliver the initiate.
  manager2->OnIncomingMessage(stanza1.get());
  stanza1.reset(manhandler2->CheckNextStanza(
    "<cli:iq to=\"[e-mail]\" id=\"0\" type=\"result\" from=\"[e-mail]\""
    " xmlns:cli=\"jabber:client\"/>"));

  // If client1 is old, we will not see a transport-accept.  If client2 is old,
  // then we should act as if it did not send one.
  if (!old1) {
    stanza1.reset(manhandler2->CheckNextStanza(
      "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"2\""
      " xmlns:cli=\"jabber:client\">"
      "<session xmlns=\"http://www.google.com/session\""
      " type=\"transport-accept\" id=\"2154761789\" initiator=\"[e-mail]\">"
      "<p:transport xmlns:p=\"http://www.google.com/transport/p2p\"/>"
      "</session>"
      "</cli:iq>"));
  } else {
    GetNextID();  // Advance the ID count to be the same in all cases.
    stanza1.reset(NULL);
  }
  if (old2) {
    stanza1.reset(NULL);
  }
  manhandler2->CheckNoStanza();
  ASSERT(manhandler2->create_count == 1);
  ASSERT(manhandler2->last_id == session1->id());

  Session* session2 = manager2->GetSession(session1->id());
  ASSERT(session2);
  ASSERT(session1->id() == session2->id());
  ASSERT(manhandler2->last_id == session2->id());
  ASSERT(session2->state() == Session::STATE_RECEIVEDINITIATE);
  scoped_ptr<SessionHandler> handler2(new SessionHandler(session2));
  handler2->PrepareTransport();

  ASSERT(session2->name() == session1->remote_name());
  ASSERT(session1->name() == session2->remote_name());

  ASSERT(session2->transport() != NULL);
  ASSERT(session2->transport()->name() == kNsP2pTransport);

  ASSERT(client->create_count == 2);
  TransportChannel* chan2a = client->a;
  scoped_ptr<ChannelHandler> chanhandler2a(new ChannelHandler(chan2a));
  TransportChannel* chan2b = client->b;
  scoped_ptr<ChannelHandler> chanhandler2b(new ChannelHandler(chan2b));

  // Deliver the candidates.
  manager2->OnIncomingMessage(stanza2.get());
  stanza2.reset(manhandler2->CheckNextStanza(
    "<cli:iq to=\"[e-mail]\" id=\"1\" type=\"result\" from=\"[e-mail]\""
    " xmlns:cli=\"jabber:client\"/>"));

  signaling_thread->ProcessMessages(10);

  // If client1 is old, we should see a candidates message instead of a
  // transport-info.  If client2 is old, we should act as if we did.
  const char* kCandidates2 =
    "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"3\""
    " xmlns:cli=\"jabber:client\">"
    "<session xmlns=\"http://www.google.com/session\" type=\"candidates\""
    " id=\"2154761789\" initiator=\"[e-mail]\">"
    "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28673\""
    " preference=\"1\" username=\"FJDz3iuXjbQJDRjs\" protocol=\"udp\""
    " generation=\"0\" password=\"Ca5daV9m6G91qhlM\" type=\"local\""
    " network=\"network\"/>"
    "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28678\""
    " preference=\"1\" username=\"xlN53r3Jn/R5XuCt\" protocol=\"udp\""
    " generation=\"0\" password=\"rgik2pKsjaPSUdJd\" type=\"local\""
    " network=\"network\"/>"
    "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28683\""
    " preference=\"1\" username=\"IBZ8CSq8ot2+pSMp\" protocol=\"udp\""
    " generation=\"0\" password=\"i7RcDsGntMI6fzdd\" type=\"local\""
    " network=\"network\"/>"
    "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28688\""
    " preference=\"1\" username=\"SEtih9PYtMHCAlMI\" protocol=\"udp\""
    " generation=\"0\" password=\"wROrHJ3+gDxUUMp1\" type=\"local\""
    " network=\"network\"/>"
    "</session>"
    "</cli:iq>";
  if (old1) {
    stanza2.reset(manhandler2->CheckNextStanza(kCandidates2));
  } else {
    stanza2.reset(manhandler2->CheckNextStanza(
      "<cli:iq to=\"[e-mail]\" type=\"set\" from=\"[e-mail]\" id=\"3\""
      " xmlns:cli=\"jabber:client\">"
      "<session xmlns=\"http://www.google.com/session\" type=\"transport-info\""
      " id=\"2154761789\" initiator=\"[e-mail]\">"
      "<p:transport xmlns:p=\"http://www.google.com/transport/p2p\">"
      "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28673\""
      " preference=\"1\" username=\"FJDz3iuXjbQJDRjs\" protocol=\"udp\""
      " generation=\"0\" password=\"Ca5daV9m6G91qhlM\" type=\"local\""
      " network=\"network\"/>"
      "<candidate name=\"a\" address=\"127.0.0.1\" port=\"28678\""
      " preference=\"1\" username=\"xlN53r3Jn/R5XuCt\" protocol=\"udp\""
      " generation=\"0\" password=\"rgik2pKsjaPSUdJd\" type=\"local\""
      " network=\"network\"/>"
      "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28683\""
      " preference=\"1\" username=\"IBZ8CSq8ot2+pSMp\" protocol=\"udp\""
      " generation=\"0\" password=\"i7RcDsGntMI6fzdd\" type=\"local\""
      " network=\"network\"/>"
      "<candidate name=\"b\" address=\"127.0.0.1\" port=\"28688\""
      " preference=\"1\" username=\"SEtih9PYtMHCAlMI\" protocol=\"udp\""
      " generation=\"0\" password=\"wROrHJ3+gDxUUMp1\" type=\"local\""
      " network=\"network\"/>"
      "</p:transport>"
      "</session>"
      "</cli:iq>"));
  }
  if (old2) {
    stanza2.reset(XmlElement::ForStr(kCandidates2));
  }