Multicast DNS implementation (initial)

net/dns/record_parsed_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/dns/record_parsed.h"
 
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_test_util.h"
 #include "net/dns/record_rdata.h"
@@ skipping 34 matching lines @@
   ASSERT_EQ(dns_protocol::kClassIN, record->klass());
 
   rdata = record->rdata<CnameRecordRdata>();
   ASSERT_TRUE(rdata != NULL);
   ASSERT_EQ(kT1CanonName, rdata->cname());
 
   ASSERT_FALSE(record->rdata<SrvRecordRdata>());
   ASSERT_TRUE(record->IsEqual(record.get(), true));
 }
 
+TEST(RecordParsedTest, Clone) {
+  DnsRecordParser parser(kT1ResponseDatagram, sizeof(kT1ResponseDatagram),
+                         sizeof(dns_protocol::Header));
+  scoped_ptr<const RecordParsed> record;
+  const CnameRecordRdata* rdata;
+
+  parser.SkipQuestion();
+  record = RecordParsed::CreateFrom(&parser, base::Time());
+  EXPECT_TRUE(record.get() != NULL);
+
+  scoped_ptr<const RecordParsed> record2;
+  record2 = record->Clone();
+
+  record.reset();
+
+  ASSERT_EQ("codereview.chromium.org", record2->name());
+  ASSERT_EQ(dns_protocol::kTypeCNAME, record2->type());
+  ASSERT_EQ(dns_protocol::kClassIN, record2->klass());
+
+  rdata = record2->rdata<CnameRecordRdata>();
+  EXPECT_TRUE(rdata != NULL);
+  ASSERT_EQ(kT1CanonName, rdata->cname());
+
+  ASSERT_FALSE(record2->rdata<SrvRecordRdata>());
+}
+
 TEST(RecordParsedTest, CacheFlushBitCompare) {
   DnsRecordParser parser1(kT1ResponseDatagram, sizeof(kT1ResponseDatagram),
                          sizeof(dns_protocol::Header));
   parser1.SkipQuestion();
   scoped_ptr<const RecordParsed> record1 =
       RecordParsed::CreateFrom(&parser1, base::Time());
 
   DnsRecordParser parser2(kT1ResponseWithCacheFlushBit,
                           sizeof(kT1ResponseWithCacheFlushBit),
                           0);
 
   scoped_ptr<const RecordParsed> record2 =
       RecordParsed::CreateFrom(&parser2, base::Time());
 
   EXPECT_FALSE(record1->IsEqual(record2.get(), false));
   EXPECT_TRUE(record1->IsEqual(record2.get(), true));
   EXPECT_FALSE(record2->IsEqual(record1.get(), false));
   EXPECT_TRUE(record2->IsEqual(record1.get(), true));
 }
 
-}  //namespace net
+}  // namespace net