Change StunMessage::AddAttribute return type from bool to void.

webrtc/p2p/base/stun_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 867 matching lines @@
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
-  EXPECT_TRUE(msg.AddAttribute(addr));
+  msg.AddAttribute(addr);
 
   CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6MappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
   ASSERT_EQ(0, memcmp(bytes.c_str(), kStunMessageWithIPv6MappedAddress, len1));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4MappedAddress);
 
   rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort4);
   addr->SetAddress(test_addr);
-  EXPECT_TRUE(msg.AddAttribute(addr));
+  msg.AddAttribute(addr);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4MappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
   ASSERT_EQ(0, memcmp(bytes.c_str(), kStunMessageWithIPv4MappedAddress, len1));
 }
 
 TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv6XorMappedAddress);
 
   rtc::IPAddress test_ip(kIPv6TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId2),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort1);
   addr->SetAddress(test_addr);
-  EXPECT_TRUE(msg.AddAttribute(addr));
+  msg.AddAttribute(addr);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6XorMappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
@@ skipping 10 matching lines @@
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
   rtc::SocketAddress test_addr(test_ip, kTestMessagePort3);
   addr->SetAddress(test_addr);
-  EXPECT_TRUE(msg.AddAttribute(addr));
+  msg.AddAttribute(addr);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4XorMappedAddress));
   int len1 = static_cast<int>(out.Length());
   rtc::ByteBufferReader read_buf(out);
   std::string bytes;
   read_buf.ReadString(&bytes, len1);
@@ skipping 79 matching lines @@
   size_t size = sizeof(kStunMessageWithErrorAttribute);
 
   msg.SetType(STUN_BINDING_ERROR_RESPONSE);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
   StunErrorCodeAttribute* errorcode = StunAttribute::CreateErrorCode();
   errorcode->SetCode(kTestErrorCode);
   errorcode->SetReason(kTestErrorReason);
-  EXPECT_TRUE(msg.AddAttribute(errorcode));
+  msg.AddAttribute(errorcode);
   CheckStunHeader(msg, STUN_BINDING_ERROR_RESPONSE, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // No padding.
   ASSERT_EQ(0, memcmp(out.Data(), kStunMessageWithErrorAttribute, size));
 }
 
 TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithUInt16ListAttribute);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId2),
                   kStunTransactionIdLength));
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
   StunUInt16ListAttribute* list = StunAttribute::CreateUnknownAttributes();
   list->AddType(0x1U);
   list->AddType(0x1000U);
   list->AddType(0xAB0CU);
-  EXPECT_TRUE(msg.AddAttribute(list));
+  msg.AddAttribute(list);
   CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // Check everything up to the padding.
   ASSERT_EQ(0,
             memcmp(out.Data(), kStunMessageWithUInt16ListAttribute, size - 2));
 }
 
 TEST_F(StunTest, WriteMessageWithOriginAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithOriginAttribute);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
       std::string(reinterpret_cast<const char*>(kTestTransactionId1),
                   kStunTransactionIdLength));
   StunByteStringAttribute* origin =
       new StunByteStringAttribute(STUN_ATTR_ORIGIN, kTestOrigin);
-  EXPECT_TRUE(msg.AddAttribute(origin));
+  msg.AddAttribute(origin);
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // Check everything up to the padding
   ASSERT_EQ(0, memcmp(out.Data(), kStunMessageWithOriginAttribute, size - 2));
 }
 
 // Test that we fail to read messages with invalid lengths.
 void CheckFailureToRead(const unsigned char* testcase, size_t length) {
@@ skipping 252 matching lines @@
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   ASSERT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   StunAddressAttribute* addr2 =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
-  EXPECT_TRUE(msg2.AddAttribute(addr2));
+  msg2.AddAttribute(addr2);
 
   const StunByteStringAttribute* bytes = msg.GetByteString(STUN_ATTR_USERNAME);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(12U, bytes->length());
   EXPECT_EQ("abcdefghijkl", bytes->GetString());
 
   StunByteStringAttribute* bytes2 =
   StunAttribute::CreateByteString(STUN_ATTR_USERNAME);
   bytes2->CopyBytes("abcdefghijkl");
-  EXPECT_TRUE(msg2.AddAttribute(bytes2));
+  msg2.AddAttribute(bytes2);
 
   const StunUInt32Attribute* uval = msg.GetUInt32(STUN_ATTR_LIFETIME);
   ASSERT_TRUE(uval != NULL);
   EXPECT_EQ(11U, uval->value());
 
   StunUInt32Attribute* uval2 = StunAttribute::CreateUInt32(STUN_ATTR_LIFETIME);
   uval2->SetValue(11);
-  EXPECT_TRUE(msg2.AddAttribute(uval2));
+  msg2.AddAttribute(uval2);
 
   bytes = msg.GetByteString(STUN_ATTR_MAGIC_COOKIE);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(4U, bytes->length());
   EXPECT_EQ(0,
             memcmp(bytes->bytes(),
                    TURN_MAGIC_COOKIE_VALUE,
                    sizeof(TURN_MAGIC_COOKIE_VALUE)));
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_MAGIC_COOKIE);
   bytes2->CopyBytes(reinterpret_cast<const char*>(TURN_MAGIC_COOKIE_VALUE),
                     sizeof(TURN_MAGIC_COOKIE_VALUE));
-  EXPECT_TRUE(msg2.AddAttribute(bytes2));
+  msg2.AddAttribute(bytes2);
 
   uval = msg.GetUInt32(STUN_ATTR_BANDWIDTH);
   ASSERT_TRUE(uval != NULL);
   EXPECT_EQ(6U, uval->value());
 
   uval2 = StunAttribute::CreateUInt32(STUN_ATTR_BANDWIDTH);
   uval2->SetValue(6);
-  EXPECT_TRUE(msg2.AddAttribute(uval2));
+  msg2.AddAttribute(uval2);
 
   addr = msg.GetAddress(STUN_ATTR_DESTINATION_ADDRESS);
   ASSERT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   addr2 = StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
-  EXPECT_TRUE(msg2.AddAttribute(addr2));
+  msg2.AddAttribute(addr2);
 
   addr = msg.GetAddress(STUN_ATTR_SOURCE_ADDRESS2);
   ASSERT_TRUE(addr != NULL);
   EXPECT_EQ(1, addr->family());
   EXPECT_EQ(13, addr->port());
   EXPECT_EQ(legacy_ip, addr->ipaddr());
 
   addr2 = StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
   addr2->SetPort(13);
   addr2->SetIP(legacy_ip);
-  EXPECT_TRUE(msg2.AddAttribute(addr2));
+  msg2.AddAttribute(addr2);
 
   bytes = msg.GetByteString(STUN_ATTR_DATA);
   ASSERT_TRUE(bytes != NULL);
   EXPECT_EQ(7U, bytes->length());
   EXPECT_EQ("abcdefg", bytes->GetString());
 
   bytes2 = StunAttribute::CreateByteString(STUN_ATTR_DATA);
   bytes2->CopyBytes("abcdefg");
-  EXPECT_TRUE(msg2.AddAttribute(bytes2));
+  msg2.AddAttribute(bytes2);
 
   rtc::ByteBufferWriter out;
   EXPECT_TRUE(msg.Write(&out));
   EXPECT_EQ(size, out.Length());
   size_t len1 = out.Length();
   rtc::ByteBufferReader read_buf(out);
   std::string outstring;
   read_buf.ReadString(&outstring, len1);
   EXPECT_EQ(0, memcmp(outstring.c_str(), input, len1));
 
   rtc::ByteBufferWriter out2;
   EXPECT_TRUE(msg2.Write(&out2));
   EXPECT_EQ(size, out2.Length());
   size_t len2 = out2.Length();
   rtc::ByteBufferReader read_buf2(out2);
   std::string outstring2;
   read_buf2.ReadString(&outstring2, len2);
   EXPECT_EQ(0, memcmp(outstring2.c_str(), input, len2));
 }
 
 }  // namespace cricket