talk/app/webrtc/datachannel_unittest.cc - src - Git at Google

 /*
  * libjingle
  * Copyright 2013 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "talk/app/webrtc/datachannel.h"
 #include "talk/app/webrtc/sctputils.h"
 #include "talk/app/webrtc/test/fakedatachannelprovider.h"
 #include "webrtc/base/gunit.h"

 using webrtc::DataChannel;
 using webrtc::SctpSidAllocator;

 class FakeDataChannelObserver : public webrtc::DataChannelObserver {
  public:
   FakeDataChannelObserver()
       : messages_received_(0),
         on_state_change_count_(0),
         on_buffered_amount_change_count_(0) {}

   void OnStateChange() {
     ++on_state_change_count_;
   }

   void OnBufferedAmountChange(uint64_t previous_amount) {
     ++on_buffered_amount_change_count_;
   }

   void OnMessage(const webrtc::DataBuffer& buffer) {
     ++messages_received_;
   }

   size_t messages_received() const {
     return messages_received_;
   }

   void ResetOnStateChangeCount() {
     on_state_change_count_ = 0;
   }

   void ResetOnBufferedAmountChangeCount() {
     on_buffered_amount_change_count_ = 0;
   }

   size_t on_state_change_count() const {
     return on_state_change_count_;
   }

   size_t on_buffered_amount_change_count() const {
     return on_buffered_amount_change_count_;
   }

  private:
   size_t messages_received_;
   size_t on_state_change_count_;
   size_t on_buffered_amount_change_count_;
 };

 class SctpDataChannelTest : public testing::Test {
  protected:
   SctpDataChannelTest()
       : webrtc_data_channel_(
           DataChannel::Create(
               &provider_, cricket::DCT_SCTP, "test", init_)) {
   }

   void SetChannelReady() {
     provider_.set_transport_available(true);
     webrtc_data_channel_->OnTransportChannelCreated();
     if (webrtc_data_channel_->id() < 0) {
       webrtc_data_channel_->SetSctpSid(0);
     }
     provider_.set_ready_to_send(true);
   }

   void AddObserver() {
     observer_.reset(new FakeDataChannelObserver());
     webrtc_data_channel_->RegisterObserver(observer_.get());
   }

   webrtc::InternalDataChannelInit init_;
   FakeDataChannelProvider provider_;
   rtc::scoped_ptr<FakeDataChannelObserver> observer_;
   rtc::scoped_refptr<DataChannel> webrtc_data_channel_;
 };

 // Verifies that the data channel is connected to the transport after creation.
 TEST_F(SctpDataChannelTest, ConnectedToTransportOnCreated) {
   provider_.set_transport_available(true);
   rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init_);

   EXPECT_TRUE(provider_.IsConnected(dc.get()));
   // The sid is not set yet, so it should not have added the streams.
   EXPECT_FALSE(provider_.IsSendStreamAdded(dc->id()));
   EXPECT_FALSE(provider_.IsRecvStreamAdded(dc->id()));

   dc->SetSctpSid(0);
   EXPECT_TRUE(provider_.IsSendStreamAdded(dc->id()));
   EXPECT_TRUE(provider_.IsRecvStreamAdded(dc->id()));
 }

 // Verifies that the data channel is connected to the transport if the transport
 // is not available initially and becomes available later.
 TEST_F(SctpDataChannelTest, ConnectedAfterTransportBecomesAvailable) {
   EXPECT_FALSE(provider_.IsConnected(webrtc_data_channel_.get()));

   provider_.set_transport_available(true);
   webrtc_data_channel_->OnTransportChannelCreated();
   EXPECT_TRUE(provider_.IsConnected(webrtc_data_channel_.get()));
 }

 // Tests the state of the data channel.
 TEST_F(SctpDataChannelTest, StateTransition) {
   EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
             webrtc_data_channel_->state());
   SetChannelReady();

   EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
   webrtc_data_channel_->Close();
   EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
             webrtc_data_channel_->state());
   // Verifies that it's disconnected from the transport.
   EXPECT_FALSE(provider_.IsConnected(webrtc_data_channel_.get()));
 }

 // Tests that DataChannel::buffered_amount() is correct after the channel is
 // blocked.
 TEST_F(SctpDataChannelTest, BufferedAmountWhenBlocked) {
   AddObserver();
   SetChannelReady();
   webrtc::DataBuffer buffer("abcd");
   EXPECT_TRUE(webrtc_data_channel_->Send(buffer));

   EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
   EXPECT_EQ(0U, observer_->on_buffered_amount_change_count());

   provider_.set_send_blocked(true);

   const int number_of_packets = 3;
   for (int i = 0; i < number_of_packets; ++i) {
     EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
   }
   EXPECT_EQ(buffer.data.size() * number_of_packets,
             webrtc_data_channel_->buffered_amount());
   EXPECT_EQ(number_of_packets, observer_->on_buffered_amount_change_count());
 }

 // Tests that the queued data are sent when the channel transitions from blocked
 // to unblocked.
 TEST_F(SctpDataChannelTest, QueuedDataSentWhenUnblocked) {
   AddObserver();
   SetChannelReady();
   webrtc::DataBuffer buffer("abcd");
   provider_.set_send_blocked(true);
   EXPECT_TRUE(webrtc_data_channel_->Send(buffer));

   EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());

   provider_.set_send_blocked(false);
   SetChannelReady();
   EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
   EXPECT_EQ(2U, observer_->on_buffered_amount_change_count());
 }

 // Tests that no crash when the channel is blocked right away while trying to
 // send queued data.
 TEST_F(SctpDataChannelTest, BlockedWhenSendQueuedDataNoCrash) {
   AddObserver();
   SetChannelReady();
   webrtc::DataBuffer buffer("abcd");
   provider_.set_send_blocked(true);
   EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
   EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());

   // Set channel ready while it is still blocked.
   SetChannelReady();
   EXPECT_EQ(buffer.size(), webrtc_data_channel_->buffered_amount());
   EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());

   // Unblock the channel to send queued data again, there should be no crash.
   provider_.set_send_blocked(false);
   SetChannelReady();
   EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
   EXPECT_EQ(2U, observer_->on_buffered_amount_change_count());
 }

 // Tests that the queued control message is sent when channel is ready.
 TEST_F(SctpDataChannelTest, OpenMessageSent) {
   // Initially the id is unassigned.
   EXPECT_EQ(-1, webrtc_data_channel_->id());

   SetChannelReady();
   EXPECT_GE(webrtc_data_channel_->id(), 0);
   EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
   EXPECT_EQ(provider_.last_send_data_params().ssrc,
             static_cast<uint32_t>(webrtc_data_channel_->id()));
 }

 TEST_F(SctpDataChannelTest, QueuedOpenMessageSent) {
   provider_.set_send_blocked(true);
   SetChannelReady();
   provider_.set_send_blocked(false);

   EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
   EXPECT_EQ(provider_.last_send_data_params().ssrc,
             static_cast<uint32_t>(webrtc_data_channel_->id()));
 }

 // Tests that the DataChannel created after transport gets ready can enter OPEN
 // state.
 TEST_F(SctpDataChannelTest, LateCreatedChannelTransitionToOpen) {
   SetChannelReady();
   webrtc::InternalDataChannelInit init;
   init.id = 1;
   rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init);
   EXPECT_EQ(webrtc::DataChannelInterface::kConnecting, dc->state());
   EXPECT_TRUE_WAIT(webrtc::DataChannelInterface::kOpen == dc->state(),
                    1000);
 }

 // Tests that an unordered DataChannel sends data as ordered until the OPEN_ACK
 // message is received.
 TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
   SetChannelReady();
   webrtc::InternalDataChannelInit init;
   init.id = 1;
   init.ordered = false;
   rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init);

   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);

   // Sends a message and verifies it's ordered.
   webrtc::DataBuffer buffer("some data");
   ASSERT_TRUE(dc->Send(buffer));
   EXPECT_TRUE(provider_.last_send_data_params().ordered);

   // Emulates receiving an OPEN_ACK message.
   cricket::ReceiveDataParams params;
   params.ssrc = init.id;
   params.type = cricket::DMT_CONTROL;
   rtc::Buffer payload;
   webrtc::WriteDataChannelOpenAckMessage(&payload);
   dc->OnDataReceived(NULL, params, payload);

   // Sends another message and verifies it's unordered.
   ASSERT_TRUE(dc->Send(buffer));
   EXPECT_FALSE(provider_.last_send_data_params().ordered);
 }

 // Tests that an unordered DataChannel sends unordered data after any DATA
 // message is received.
 TEST_F(SctpDataChannelTest, SendUnorderedAfterReceiveData) {
   SetChannelReady();
   webrtc::InternalDataChannelInit init;
   init.id = 1;
   init.ordered = false;
   rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init);

   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);

   // Emulates receiving a DATA message.
   cricket::ReceiveDataParams params;
   params.ssrc = init.id;
   params.type = cricket::DMT_TEXT;
   webrtc::DataBuffer buffer("data");
   dc->OnDataReceived(NULL, params, buffer.data);

   // Sends a message and verifies it's unordered.
   ASSERT_TRUE(dc->Send(buffer));
   EXPECT_FALSE(provider_.last_send_data_params().ordered);
 }

 // Tests that the channel can't open until it's successfully sent the OPEN
 // message.
 TEST_F(SctpDataChannelTest, OpenWaitsForOpenMesssage) {
   webrtc::DataBuffer buffer("foo");

   provider_.set_send_blocked(true);
   SetChannelReady();
   EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
             webrtc_data_channel_->state());
   provider_.set_send_blocked(false);
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
                  webrtc_data_channel_->state(), 1000);
   EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
 }

 // Tests that close first makes sure all queued data gets sent.
 TEST_F(SctpDataChannelTest, QueuedCloseFlushes) {
   webrtc::DataBuffer buffer("foo");

   provider_.set_send_blocked(true);
   SetChannelReady();
   EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
             webrtc_data_channel_->state());
   provider_.set_send_blocked(false);
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
                  webrtc_data_channel_->state(), 1000);
   provider_.set_send_blocked(true);
   webrtc_data_channel_->Send(buffer);
   webrtc_data_channel_->Close();
   provider_.set_send_blocked(false);
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
                  webrtc_data_channel_->state(), 1000);
   EXPECT_EQ(cricket::DMT_TEXT, provider_.last_send_data_params().type);
 }

 // Tests that messages are sent with the right ssrc.
 TEST_F(SctpDataChannelTest, SendDataSsrc) {
   webrtc_data_channel_->SetSctpSid(1);
   SetChannelReady();
   webrtc::DataBuffer buffer("data");
   EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
   EXPECT_EQ(1U, provider_.last_send_data_params().ssrc);
 }

 // Tests that the incoming messages with wrong ssrcs are rejected.
 TEST_F(SctpDataChannelTest, ReceiveDataWithInvalidSsrc) {
   webrtc_data_channel_->SetSctpSid(1);
   SetChannelReady();

   AddObserver();

   cricket::ReceiveDataParams params;
   params.ssrc = 0;
   webrtc::DataBuffer buffer("abcd");
   webrtc_data_channel_->OnDataReceived(NULL, params, buffer.data);

   EXPECT_EQ(0U, observer_->messages_received());
 }

 // Tests that the incoming messages with right ssrcs are acceted.
 TEST_F(SctpDataChannelTest, ReceiveDataWithValidSsrc) {
   webrtc_data_channel_->SetSctpSid(1);
   SetChannelReady();

   AddObserver();

   cricket::ReceiveDataParams params;
   params.ssrc = 1;
   webrtc::DataBuffer buffer("abcd");

   webrtc_data_channel_->OnDataReceived(NULL, params, buffer.data);
   EXPECT_EQ(1U, observer_->messages_received());
 }

 // Tests that no CONTROL message is sent if the datachannel is negotiated and
 // not created from an OPEN message.
 TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
   webrtc::InternalDataChannelInit config;
   config.id = 1;
   config.negotiated = true;
   config.open_handshake_role = webrtc::InternalDataChannelInit::kNone;

   SetChannelReady();
   rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", config);

   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
   EXPECT_EQ(0U, provider_.last_send_data_params().ssrc);
 }

 // Tests that OPEN_ACK message is sent if the datachannel is created from an
 // OPEN message.
 TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
   webrtc::InternalDataChannelInit config;
   config.id = 1;
   config.negotiated = true;
   config.open_handshake_role = webrtc::InternalDataChannelInit::kAcker;

   SetChannelReady();
   rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", config);

   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);

   EXPECT_EQ(static_cast<unsigned int>(config.id),
             provider_.last_send_data_params().ssrc);
   EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
 }

 // Tests the OPEN_ACK role assigned by InternalDataChannelInit.
 TEST_F(SctpDataChannelTest, OpenAckRoleInitialization) {
   webrtc::InternalDataChannelInit init;
   EXPECT_EQ(webrtc::InternalDataChannelInit::kOpener, init.open_handshake_role);
   EXPECT_FALSE(init.negotiated);

   webrtc::DataChannelInit base;
   base.negotiated = true;
   webrtc::InternalDataChannelInit init2(base);
   EXPECT_EQ(webrtc::InternalDataChannelInit::kNone, init2.open_handshake_role);
 }

 // Tests that the DataChannel is closed if the sending buffer is full.
 TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) {
   SetChannelReady();

   rtc::Buffer buffer(1024);
   memset(buffer.data(), 0, buffer.size());

   webrtc::DataBuffer packet(buffer, true);
   provider_.set_send_blocked(true);

   for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
     EXPECT_TRUE(webrtc_data_channel_->Send(packet));
   }

   EXPECT_TRUE(
       webrtc::DataChannelInterface::kClosed == webrtc_data_channel_->state() ||
       webrtc::DataChannelInterface::kClosing == webrtc_data_channel_->state());
 }

 // Tests that the DataChannel is closed on transport errors.
 TEST_F(SctpDataChannelTest, ClosedOnTransportError) {
   SetChannelReady();
   webrtc::DataBuffer buffer("abcd");
   provider_.set_transport_error();

   EXPECT_TRUE(webrtc_data_channel_->Send(buffer));

   EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
             webrtc_data_channel_->state());
 }

 // Tests that a already closed DataChannel does not fire onStateChange again.
 TEST_F(SctpDataChannelTest, ClosedDataChannelDoesNotFireOnStateChange) {
   AddObserver();
   webrtc_data_channel_->Close();
   // OnStateChange called for kClosing and kClosed.
   EXPECT_EQ(2U, observer_->on_state_change_count());

   observer_->ResetOnStateChangeCount();
   webrtc_data_channel_->RemotePeerRequestClose();
   EXPECT_EQ(0U, observer_->on_state_change_count());
 }

 // Tests that RemotePeerRequestClose closes the local DataChannel.
 TEST_F(SctpDataChannelTest, RemotePeerRequestClose) {
   AddObserver();
   webrtc_data_channel_->RemotePeerRequestClose();

   // OnStateChange called for kClosing and kClosed.
   EXPECT_EQ(2U, observer_->on_state_change_count());
   EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
             webrtc_data_channel_->state());
 }

 // Tests that the DataChannel is closed if the received buffer is full.
 TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
   SetChannelReady();
   rtc::Buffer buffer(1024);
   memset(buffer.data(), 0, buffer.size());

   cricket::ReceiveDataParams params;
   params.ssrc = 0;

   // Receiving data without having an observer will overflow the buffer.
   for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
     webrtc_data_channel_->OnDataReceived(NULL, params, buffer);
   }
   EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
             webrtc_data_channel_->state());
 }

 // Tests that sending empty data returns no error and keeps the channel open.
 TEST_F(SctpDataChannelTest, SendEmptyData) {
   webrtc_data_channel_->SetSctpSid(1);
   SetChannelReady();
   EXPECT_EQ(webrtc::DataChannelInterface::kOpen,
             webrtc_data_channel_->state());

   webrtc::DataBuffer buffer("");
   EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
   EXPECT_EQ(webrtc::DataChannelInterface::kOpen,
             webrtc_data_channel_->state());
 }

 // Tests that a channel can be closed without being opened or assigned an sid.
 TEST_F(SctpDataChannelTest, NeverOpened) {
   provider_.set_transport_available(true);
   webrtc_data_channel_->OnTransportChannelCreated();
   webrtc_data_channel_->Close();
 }

 class SctpSidAllocatorTest : public testing::Test {
  protected:
   SctpSidAllocator allocator_;
 };

 // Verifies that an even SCTP id is allocated for SSL_CLIENT and an odd id for
 // SSL_SERVER.
 TEST_F(SctpSidAllocatorTest, SctpIdAllocationBasedOnRole) {
   int id;
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
   EXPECT_EQ(1, id);
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
   EXPECT_EQ(0, id);
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
   EXPECT_EQ(3, id);
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
   EXPECT_EQ(2, id);
 }

 // Verifies that SCTP ids of existing DataChannels are not reused.
 TEST_F(SctpSidAllocatorTest, SctpIdAllocationNoReuse) {
   int old_id = 1;
   EXPECT_TRUE(allocator_.ReserveSid(old_id));

   int new_id;
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &new_id));
   EXPECT_NE(old_id, new_id);

   old_id = 0;
   EXPECT_TRUE(allocator_.ReserveSid(old_id));
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &new_id));
   EXPECT_NE(old_id, new_id);
 }

 // Verifies that SCTP ids of removed DataChannels can be reused.
 TEST_F(SctpSidAllocatorTest, SctpIdReusedForRemovedDataChannel) {
   int odd_id = 1;
   int even_id = 0;
   EXPECT_TRUE(allocator_.ReserveSid(odd_id));
   EXPECT_TRUE(allocator_.ReserveSid(even_id));

   int allocated_id = -1;
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
   EXPECT_EQ(odd_id + 2, allocated_id);

   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id + 2, allocated_id);

   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
   EXPECT_EQ(odd_id + 4, allocated_id);

   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id + 4, allocated_id);

   allocator_.ReleaseSid(odd_id);
   allocator_.ReleaseSid(even_id);

   // Verifies that removed ids are reused.
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
   EXPECT_EQ(odd_id, allocated_id);

   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id, allocated_id);

   // Verifies that used higher ids are not reused.
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
   EXPECT_EQ(odd_id + 6, allocated_id);

   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id + 6, allocated_id);
 }
	/*
	* libjingle
	* Copyright 2013 Google Inc.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	*
	* 1. Redistributions of source code must retain the above copyright notice,
	* this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright notice,
	* this list of conditions and the following disclaimer in the documentation
	* and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
	* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "talk/app/webrtc/datachannel.h"
	#include "talk/app/webrtc/sctputils.h"
	#include "talk/app/webrtc/test/fakedatachannelprovider.h"
	#include "webrtc/base/gunit.h"

	using webrtc::DataChannel;
	using webrtc::SctpSidAllocator;

	class FakeDataChannelObserver : public webrtc::DataChannelObserver {
	public:
	FakeDataChannelObserver()
	: messages_received_(0),
	on_state_change_count_(0),
	on_buffered_amount_change_count_(0) {}

	void OnStateChange() {
	++on_state_change_count_;
	}

	void OnBufferedAmountChange(uint64_t previous_amount) {
	++on_buffered_amount_change_count_;
	}

	void OnMessage(const webrtc::DataBuffer& buffer) {
	++messages_received_;
	}

	size_t messages_received() const {
	return messages_received_;
	}

	void ResetOnStateChangeCount() {
	on_state_change_count_ = 0;
	}

	void ResetOnBufferedAmountChangeCount() {
	on_buffered_amount_change_count_ = 0;
	}

	size_t on_state_change_count() const {
	return on_state_change_count_;
	}

	size_t on_buffered_amount_change_count() const {
	return on_buffered_amount_change_count_;
	}

	private:
	size_t messages_received_;
	size_t on_state_change_count_;
	size_t on_buffered_amount_change_count_;
	};

	class SctpDataChannelTest : public testing::Test {
	protected:
	SctpDataChannelTest()
	: webrtc_data_channel_(
	DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test", init_)) {
	}

	void SetChannelReady() {
	provider_.set_transport_available(true);
	webrtc_data_channel_->OnTransportChannelCreated();
	if (webrtc_data_channel_->id() < 0) {
	webrtc_data_channel_->SetSctpSid(0);
	}
	provider_.set_ready_to_send(true);
	}

	void AddObserver() {
	observer_.reset(new FakeDataChannelObserver());
	webrtc_data_channel_->RegisterObserver(observer_.get());
	}

	webrtc::InternalDataChannelInit init_;
	FakeDataChannelProvider provider_;
	rtc::scoped_ptr<FakeDataChannelObserver> observer_;
	rtc::scoped_refptr<DataChannel> webrtc_data_channel_;
	};

	// Verifies that the data channel is connected to the transport after creation.
	TEST_F(SctpDataChannelTest, ConnectedToTransportOnCreated) {
	provider_.set_transport_available(true);
	rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test1", init_);

	EXPECT_TRUE(provider_.IsConnected(dc.get()));
	// The sid is not set yet, so it should not have added the streams.
	EXPECT_FALSE(provider_.IsSendStreamAdded(dc->id()));
	EXPECT_FALSE(provider_.IsRecvStreamAdded(dc->id()));

	dc->SetSctpSid(0);
	EXPECT_TRUE(provider_.IsSendStreamAdded(dc->id()));
	EXPECT_TRUE(provider_.IsRecvStreamAdded(dc->id()));
	}

	// Verifies that the data channel is connected to the transport if the transport
	// is not available initially and becomes available later.
	TEST_F(SctpDataChannelTest, ConnectedAfterTransportBecomesAvailable) {
	EXPECT_FALSE(provider_.IsConnected(webrtc_data_channel_.get()));

	provider_.set_transport_available(true);
	webrtc_data_channel_->OnTransportChannelCreated();
	EXPECT_TRUE(provider_.IsConnected(webrtc_data_channel_.get()));
	}

	// Tests the state of the data channel.
	TEST_F(SctpDataChannelTest, StateTransition) {
	EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
	webrtc_data_channel_->state());
	SetChannelReady();

	EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
	webrtc_data_channel_->Close();
	EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
	webrtc_data_channel_->state());
	// Verifies that it's disconnected from the transport.
	EXPECT_FALSE(provider_.IsConnected(webrtc_data_channel_.get()));
	}

	// Tests that DataChannel::buffered_amount() is correct after the channel is
	// blocked.
	TEST_F(SctpDataChannelTest, BufferedAmountWhenBlocked) {
	AddObserver();
	SetChannelReady();
	webrtc::DataBuffer buffer("abcd");
	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));

	EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
	EXPECT_EQ(0U, observer_->on_buffered_amount_change_count());

	provider_.set_send_blocked(true);

	const int number_of_packets = 3;
	for (int i = 0; i < number_of_packets; ++i) {
	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
	}
	EXPECT_EQ(buffer.data.size() * number_of_packets,
	webrtc_data_channel_->buffered_amount());
	EXPECT_EQ(number_of_packets, observer_->on_buffered_amount_change_count());
	}

	// Tests that the queued data are sent when the channel transitions from blocked
	// to unblocked.
	TEST_F(SctpDataChannelTest, QueuedDataSentWhenUnblocked) {
	AddObserver();
	SetChannelReady();
	webrtc::DataBuffer buffer("abcd");
	provider_.set_send_blocked(true);
	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));

	EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());

	provider_.set_send_blocked(false);
	SetChannelReady();
	EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
	EXPECT_EQ(2U, observer_->on_buffered_amount_change_count());
	}

	// Tests that no crash when the channel is blocked right away while trying to
	// send queued data.
	TEST_F(SctpDataChannelTest, BlockedWhenSendQueuedDataNoCrash) {
	AddObserver();
	SetChannelReady();
	webrtc::DataBuffer buffer("abcd");
	provider_.set_send_blocked(true);
	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
	EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());

	// Set channel ready while it is still blocked.
	SetChannelReady();
	EXPECT_EQ(buffer.size(), webrtc_data_channel_->buffered_amount());
	EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());

	// Unblock the channel to send queued data again, there should be no crash.
	provider_.set_send_blocked(false);
	SetChannelReady();
	EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
	EXPECT_EQ(2U, observer_->on_buffered_amount_change_count());
	}

	// Tests that the queued control message is sent when channel is ready.
	TEST_F(SctpDataChannelTest, OpenMessageSent) {
	// Initially the id is unassigned.
	EXPECT_EQ(-1, webrtc_data_channel_->id());

	SetChannelReady();
	EXPECT_GE(webrtc_data_channel_->id(), 0);
	EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
	EXPECT_EQ(provider_.last_send_data_params().ssrc,
	static_cast<uint32_t>(webrtc_data_channel_->id()));
	}

	TEST_F(SctpDataChannelTest, QueuedOpenMessageSent) {
	provider_.set_send_blocked(true);
	SetChannelReady();
	provider_.set_send_blocked(false);

	EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
	EXPECT_EQ(provider_.last_send_data_params().ssrc,
	static_cast<uint32_t>(webrtc_data_channel_->id()));
	}

	// Tests that the DataChannel created after transport gets ready can enter OPEN
	// state.
	TEST_F(SctpDataChannelTest, LateCreatedChannelTransitionToOpen) {
	SetChannelReady();
	webrtc::InternalDataChannelInit init;
	init.id = 1;
	rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test1", init);
	EXPECT_EQ(webrtc::DataChannelInterface::kConnecting, dc->state());
	EXPECT_TRUE_WAIT(webrtc::DataChannelInterface::kOpen == dc->state(),
	1000);
	}

	// Tests that an unordered DataChannel sends data as ordered until the OPEN_ACK
	// message is received.
	TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
	SetChannelReady();
	webrtc::InternalDataChannelInit init;
	init.id = 1;
	init.ordered = false;
	rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test1", init);

	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);

	// Sends a message and verifies it's ordered.
	webrtc::DataBuffer buffer("some data");
	ASSERT_TRUE(dc->Send(buffer));
	EXPECT_TRUE(provider_.last_send_data_params().ordered);

	// Emulates receiving an OPEN_ACK message.
	cricket::ReceiveDataParams params;
	params.ssrc = init.id;
	params.type = cricket::DMT_CONTROL;
	rtc::Buffer payload;
	webrtc::WriteDataChannelOpenAckMessage(&payload);
	dc->OnDataReceived(NULL, params, payload);

	// Sends another message and verifies it's unordered.
	ASSERT_TRUE(dc->Send(buffer));
	EXPECT_FALSE(provider_.last_send_data_params().ordered);
	}

	// Tests that an unordered DataChannel sends unordered data after any DATA
	// message is received.
	TEST_F(SctpDataChannelTest, SendUnorderedAfterReceiveData) {
	SetChannelReady();
	webrtc::InternalDataChannelInit init;
	init.id = 1;
	init.ordered = false;
	rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test1", init);

	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);

	// Emulates receiving a DATA message.
	cricket::ReceiveDataParams params;
	params.ssrc = init.id;
	params.type = cricket::DMT_TEXT;
	webrtc::DataBuffer buffer("data");
	dc->OnDataReceived(NULL, params, buffer.data);

	// Sends a message and verifies it's unordered.
	ASSERT_TRUE(dc->Send(buffer));
	EXPECT_FALSE(provider_.last_send_data_params().ordered);
	}

	// Tests that the channel can't open until it's successfully sent the OPEN
	// message.
	TEST_F(SctpDataChannelTest, OpenWaitsForOpenMesssage) {
	webrtc::DataBuffer buffer("foo");

	provider_.set_send_blocked(true);
	SetChannelReady();
	EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
	webrtc_data_channel_->state());
	provider_.set_send_blocked(false);
	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
	webrtc_data_channel_->state(), 1000);
	EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
	}

	// Tests that close first makes sure all queued data gets sent.
	TEST_F(SctpDataChannelTest, QueuedCloseFlushes) {
	webrtc::DataBuffer buffer("foo");

	provider_.set_send_blocked(true);
	SetChannelReady();
	EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
	webrtc_data_channel_->state());
	provider_.set_send_blocked(false);
	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
	webrtc_data_channel_->state(), 1000);
	provider_.set_send_blocked(true);
	webrtc_data_channel_->Send(buffer);
	webrtc_data_channel_->Close();
	provider_.set_send_blocked(false);
	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
	webrtc_data_channel_->state(), 1000);
	EXPECT_EQ(cricket::DMT_TEXT, provider_.last_send_data_params().type);
	}

	// Tests that messages are sent with the right ssrc.
	TEST_F(SctpDataChannelTest, SendDataSsrc) {
	webrtc_data_channel_->SetSctpSid(1);
	SetChannelReady();
	webrtc::DataBuffer buffer("data");
	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
	EXPECT_EQ(1U, provider_.last_send_data_params().ssrc);
	}

	// Tests that the incoming messages with wrong ssrcs are rejected.
	TEST_F(SctpDataChannelTest, ReceiveDataWithInvalidSsrc) {
	webrtc_data_channel_->SetSctpSid(1);
	SetChannelReady();

	AddObserver();

	cricket::ReceiveDataParams params;
	params.ssrc = 0;
	webrtc::DataBuffer buffer("abcd");
	webrtc_data_channel_->OnDataReceived(NULL, params, buffer.data);

	EXPECT_EQ(0U, observer_->messages_received());
	}

	// Tests that the incoming messages with right ssrcs are acceted.
	TEST_F(SctpDataChannelTest, ReceiveDataWithValidSsrc) {
	webrtc_data_channel_->SetSctpSid(1);
	SetChannelReady();

	AddObserver();

	cricket::ReceiveDataParams params;
	params.ssrc = 1;
	webrtc::DataBuffer buffer("abcd");

	webrtc_data_channel_->OnDataReceived(NULL, params, buffer.data);
	EXPECT_EQ(1U, observer_->messages_received());
	}

	// Tests that no CONTROL message is sent if the datachannel is negotiated and
	// not created from an OPEN message.
	TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
	webrtc::InternalDataChannelInit config;
	config.id = 1;
	config.negotiated = true;
	config.open_handshake_role = webrtc::InternalDataChannelInit::kNone;

	SetChannelReady();
	rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test1", config);

	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
	EXPECT_EQ(0U, provider_.last_send_data_params().ssrc);
	}

	// Tests that OPEN_ACK message is sent if the datachannel is created from an
	// OPEN message.
	TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
	webrtc::InternalDataChannelInit config;
	config.id = 1;
	config.negotiated = true;
	config.open_handshake_role = webrtc::InternalDataChannelInit::kAcker;

	SetChannelReady();
	rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
	&provider_, cricket::DCT_SCTP, "test1", config);

	EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);

	EXPECT_EQ(static_cast<unsigned int>(config.id),
	provider_.last_send_data_params().ssrc);
	EXPECT_EQ(cricket::DMT_CONTROL, provider_.last_send_data_params().type);
	}

	// Tests the OPEN_ACK role assigned by InternalDataChannelInit.
	TEST_F(SctpDataChannelTest, OpenAckRoleInitialization) {
	webrtc::InternalDataChannelInit init;
	EXPECT_EQ(webrtc::InternalDataChannelInit::kOpener, init.open_handshake_role);
	EXPECT_FALSE(init.negotiated);

	webrtc::DataChannelInit base;
	base.negotiated = true;
	webrtc::InternalDataChannelInit init2(base);
	EXPECT_EQ(webrtc::InternalDataChannelInit::kNone, init2.open_handshake_role);
	}

	// Tests that the DataChannel is closed if the sending buffer is full.
	TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) {
	SetChannelReady();

	rtc::Buffer buffer(1024);
	memset(buffer.data(), 0, buffer.size());

	webrtc::DataBuffer packet(buffer, true);
	provider_.set_send_blocked(true);

	for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
	EXPECT_TRUE(webrtc_data_channel_->Send(packet));
	}

	EXPECT_TRUE(
	webrtc::DataChannelInterface::kClosed == webrtc_data_channel_->state() \|\|
	webrtc::DataChannelInterface::kClosing == webrtc_data_channel_->state());
	}

	// Tests that the DataChannel is closed on transport errors.
	TEST_F(SctpDataChannelTest, ClosedOnTransportError) {
	SetChannelReady();
	webrtc::DataBuffer buffer("abcd");
	provider_.set_transport_error();

	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));

	EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
	webrtc_data_channel_->state());
	}

	// Tests that a already closed DataChannel does not fire onStateChange again.
	TEST_F(SctpDataChannelTest, ClosedDataChannelDoesNotFireOnStateChange) {
	AddObserver();
	webrtc_data_channel_->Close();
	// OnStateChange called for kClosing and kClosed.
	EXPECT_EQ(2U, observer_->on_state_change_count());

	observer_->ResetOnStateChangeCount();
	webrtc_data_channel_->RemotePeerRequestClose();
	EXPECT_EQ(0U, observer_->on_state_change_count());
	}

	// Tests that RemotePeerRequestClose closes the local DataChannel.
	TEST_F(SctpDataChannelTest, RemotePeerRequestClose) {
	AddObserver();
	webrtc_data_channel_->RemotePeerRequestClose();

	// OnStateChange called for kClosing and kClosed.
	EXPECT_EQ(2U, observer_->on_state_change_count());
	EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
	webrtc_data_channel_->state());
	}

	// Tests that the DataChannel is closed if the received buffer is full.
	TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
	SetChannelReady();
	rtc::Buffer buffer(1024);
	memset(buffer.data(), 0, buffer.size());

	cricket::ReceiveDataParams params;
	params.ssrc = 0;

	// Receiving data without having an observer will overflow the buffer.
	for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
	webrtc_data_channel_->OnDataReceived(NULL, params, buffer);
	}
	EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
	webrtc_data_channel_->state());
	}

	// Tests that sending empty data returns no error and keeps the channel open.
	TEST_F(SctpDataChannelTest, SendEmptyData) {
	webrtc_data_channel_->SetSctpSid(1);
	SetChannelReady();
	EXPECT_EQ(webrtc::DataChannelInterface::kOpen,
	webrtc_data_channel_->state());

	webrtc::DataBuffer buffer("");
	EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
	EXPECT_EQ(webrtc::DataChannelInterface::kOpen,
	webrtc_data_channel_->state());
	}

	// Tests that a channel can be closed without being opened or assigned an sid.
	TEST_F(SctpDataChannelTest, NeverOpened) {
	provider_.set_transport_available(true);
	webrtc_data_channel_->OnTransportChannelCreated();
	webrtc_data_channel_->Close();
	}

	class SctpSidAllocatorTest : public testing::Test {
	protected:
	SctpSidAllocator allocator_;
	};

	// Verifies that an even SCTP id is allocated for SSL_CLIENT and an odd id for
	// SSL_SERVER.
	TEST_F(SctpSidAllocatorTest, SctpIdAllocationBasedOnRole) {
	int id;
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
	EXPECT_EQ(1, id);
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
	EXPECT_EQ(0, id);
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
	EXPECT_EQ(3, id);
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
	EXPECT_EQ(2, id);
	}

	// Verifies that SCTP ids of existing DataChannels are not reused.
	TEST_F(SctpSidAllocatorTest, SctpIdAllocationNoReuse) {
	int old_id = 1;
	EXPECT_TRUE(allocator_.ReserveSid(old_id));

	int new_id;
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &new_id));
	EXPECT_NE(old_id, new_id);

	old_id = 0;
	EXPECT_TRUE(allocator_.ReserveSid(old_id));
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &new_id));
	EXPECT_NE(old_id, new_id);
	}

	// Verifies that SCTP ids of removed DataChannels can be reused.
	TEST_F(SctpSidAllocatorTest, SctpIdReusedForRemovedDataChannel) {
	int odd_id = 1;
	int even_id = 0;
	EXPECT_TRUE(allocator_.ReserveSid(odd_id));
	EXPECT_TRUE(allocator_.ReserveSid(even_id));

	int allocated_id = -1;
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
	EXPECT_EQ(odd_id + 2, allocated_id);

	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
	EXPECT_EQ(even_id + 2, allocated_id);

	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
	EXPECT_EQ(odd_id + 4, allocated_id);

	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
	EXPECT_EQ(even_id + 4, allocated_id);

	allocator_.ReleaseSid(odd_id);
	allocator_.ReleaseSid(even_id);

	// Verifies that removed ids are reused.
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
	EXPECT_EQ(odd_id, allocated_id);

	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
	EXPECT_EQ(even_id, allocated_id);

	// Verifies that used higher ids are not reused.
	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
	EXPECT_EQ(odd_id + 6, allocated_id);

	EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
	EXPECT_EQ(even_id + 6, allocated_id);
	}