Add a builder to PrimitiveSet and make the class itself immutable.

This may break users which build a primitive set themselves -- we do not expect anyone to actually do this. If you are broken, please check if you can use the newly added Builder instead. Also, please file an issue if you need support.

#tinkApiChange

PiperOrigin-RevId: 497148275

1 files changed, 376 insertions, 40 deletions

diff --git a/cc/core/primitive_set_test.cc b/cc/core/primitive_set_test.cc
index 3f3ebdf15..758da3423 100644
--- a/cc/core/primitive_set_test.cc
+++ b/cc/core/primitive_set_test.cc
@@ -41,11 +41,9 @@ namespace crypto {
 namespace tink {
 namespace {
 
-class PrimitiveSetTest : public ::testing::Test {
-};
+class PrimitiveSetTest : public ::testing::Test {};
 
-void add_primitives(PrimitiveSet<Mac>* primitive_set,
-                    int key_id_offset,
+void add_primitives(PrimitiveSet<Mac>* primitive_set, int key_id_offset,
                     int primitives_count) {
   for (int i = 0; i < primitives_count; i++) {
     int key_id = key_id_offset + i;
@@ -59,8 +57,20 @@ void add_primitives(PrimitiveSet<Mac>* primitive_set,
   }
 }
 
-void access_primitives(PrimitiveSet<Mac>* primitive_set,
-                       int key_id_offset,
+void add_primitives(PrimitiveSet<Mac>::Builder* primitive_set_builder,
+                    int key_id_offset, int primitives_count) {
+  for (int i = 0; i < primitives_count; i++) {
+    int key_id = key_id_offset + i;
+    KeysetInfo::KeyInfo key_info;
+    key_info.set_output_prefix_type(OutputPrefixType::TINK);
+    key_info.set_key_id(key_id);
+    key_info.set_status(KeyStatusType::ENABLED);
+    std::unique_ptr<Mac> mac(new DummyMac("dummy MAC"));
+    primitive_set_builder->AddPrimitive(std::move(mac), key_info);
+  }
+}
+
+void access_primitives(PrimitiveSet<Mac>* primitive_set, int key_id_offset,
                        int primitives_count) {
   for (int i = 0; i < primitives_count; i++) {
     int key_id = key_id_offset + i;
@@ -76,17 +86,24 @@ void access_primitives(PrimitiveSet<Mac>* primitive_set,
 }
 
 TEST_F(PrimitiveSetTest, ConcurrentOperations) {
-  PrimitiveSet<Mac> mac_set;
+  PrimitiveSet<Mac>::Builder mac_set_builder;
   int offset_a = 100;
   int offset_b = 150;
   int count = 100;
 
   // Add some primitives.
-  std::thread add_primitives_a(add_primitives, &mac_set, offset_a, count);
-  std::thread add_primitives_b(add_primitives, &mac_set, offset_b, count);
+  // See go/totw/133 on why we use a lambda here.
+  std::thread add_primitives_a(
+      [&]() { add_primitives(&mac_set_builder, offset_a, count); });
+  std::thread add_primitives_b(
+      [&]() { add_primitives(&mac_set_builder, offset_b, count); });
   add_primitives_a.join();
   add_primitives_b.join();
 
+  auto mac_set_result = std::move(mac_set_builder).Build();
+  ASSERT_TRUE(mac_set_result.ok()) << mac_set_result.status();
+  PrimitiveSet<Mac> mac_set = std::move(mac_set_result.value());
+
   // Access primitives.
   std::thread access_primitives_a(access_primitives, &mac_set, offset_a, count);
   std::thread access_primitives_b(access_primitives, &mac_set, offset_b, count);
@@ -137,7 +154,351 @@ TEST_F(PrimitiveSetTest, Basic) {
   key_2.set_key_id(key_id_2);
   key_2.set_status(KeyStatusType::ENABLED);
 
-  uint32_t key_id_3 = key_id_2;    // same id as key_2
+  uint32_t key_id_3 = key_id_2;  // same id as key_2
+  KeysetInfo::KeyInfo key_3;
+  key_3.set_output_prefix_type(OutputPrefixType::TINK);
+  key_3.set_key_id(key_id_3);
+  key_3.set_status(KeyStatusType::ENABLED);
+
+  uint32_t key_id_4 = 947327;
+  KeysetInfo::KeyInfo key_4;
+  key_4.set_output_prefix_type(OutputPrefixType::RAW);
+  key_4.set_key_id(key_id_4);
+  key_4.set_status(KeyStatusType::ENABLED);
+
+  uint32_t key_id_5 = 529472;
+  KeysetInfo::KeyInfo key_5;
+  key_5.set_output_prefix_type(OutputPrefixType::RAW);
+  key_5.set_key_id(key_id_5);
+  key_5.set_status(KeyStatusType::ENABLED);
+
+  uint32_t key_id_6 = key_id_1;  // same id as key_1
+  KeysetInfo::KeyInfo key_6;
+  key_6.set_output_prefix_type(OutputPrefixType::TINK);
+  key_6.set_key_id(key_id_6);
+  key_6.set_status(KeyStatusType::ENABLED);
+
+  PrimitiveSet<Mac>::Builder primitive_set_builder;
+
+  // Add all the primitives.
+  auto primitive_set_result = PrimitiveSet<Mac>::Builder{}
+                                  .AddPrimitive(std::move(mac_1), key_1)
+                                  .AddPrimitive(std::move(mac_2), key_2)
+                                  .AddPrimaryPrimitive(std::move(mac_3), key_3)
+                                  .AddPrimitive(std::move(mac_4), key_4)
+                                  .AddPrimitive(std::move(mac_5), key_5)
+                                  .AddPrimitive(std::move(mac_6), key_6)
+                                  .Build();
+
+  ASSERT_TRUE(primitive_set_result.ok()) << primitive_set_result.status();
+  PrimitiveSet<Mac> primitive_set = std::move(primitive_set_result.value());
+
+  std::string data = "some data";
+
+  {  // Check the primary.
+    auto primary = primitive_set.get_primary();
+    EXPECT_FALSE(primary == nullptr);
+    EXPECT_EQ(KeyStatusType::ENABLED, primary->get_status());
+    EXPECT_EQ(DummyMac(mac_name_3).ComputeMac(data).value(),
+              primary->get_primitive().ComputeMac(data).value());
+  }
+
+  {  // Check raw primitives.
+    auto& primitives = *(primitive_set.get_raw_primitives().value());
+    EXPECT_EQ(2, primitives.size());
+    EXPECT_EQ(DummyMac(mac_name_4).ComputeMac(data).value(),
+              primitives[0]->get_primitive().ComputeMac(data).value());
+    EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
+    EXPECT_EQ(key_4.key_id(), primitives[0]->get_key_id());
+    EXPECT_EQ(OutputPrefixType::RAW, primitives[0]->get_output_prefix_type());
+    EXPECT_EQ(DummyMac(mac_name_5).ComputeMac(data).value(),
+              primitives[1]->get_primitive().ComputeMac(data).value());
+    EXPECT_EQ(KeyStatusType::ENABLED, primitives[1]->get_status());
+    EXPECT_EQ(key_5.key_id(), primitives[1]->get_key_id());
+    EXPECT_EQ(OutputPrefixType::RAW, primitives[1]->get_output_prefix_type());
+  }
+
+  {  // Check Tink primitives.
+    std::string prefix = CryptoFormat::GetOutputPrefix(key_1).value();
+    auto& primitives = *(primitive_set.get_primitives(prefix).value());
+    EXPECT_EQ(2, primitives.size());
+    EXPECT_EQ(DummyMac(mac_name_1).ComputeMac(data).value(),
+              primitives[0]->get_primitive().ComputeMac(data).value());
+    EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
+    EXPECT_EQ(key_1.key_id(), primitives[0]->get_key_id());
+    EXPECT_EQ(OutputPrefixType::TINK, primitives[0]->get_output_prefix_type());
+    EXPECT_EQ(DummyMac(mac_name_6).ComputeMac(data).value(),
+              primitives[1]->get_primitive().ComputeMac(data).value());
+    EXPECT_EQ(KeyStatusType::ENABLED, primitives[1]->get_status());
+    EXPECT_EQ(key_1.key_id(), primitives[1]->get_key_id());
+    EXPECT_EQ(OutputPrefixType::TINK, primitives[1]->get_output_prefix_type());
+  }
+
+  {  // Check another Tink primitive.
+    std::string prefix = CryptoFormat::GetOutputPrefix(key_3).value();
+    auto& primitives = *(primitive_set.get_primitives(prefix).value());
+    EXPECT_EQ(1, primitives.size());
+    EXPECT_EQ(DummyMac(mac_name_3).ComputeMac(data).value(),
+              primitives[0]->get_primitive().ComputeMac(data).value());
+    EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
+    EXPECT_EQ(key_3.key_id(), primitives[0]->get_key_id());
+    EXPECT_EQ(OutputPrefixType::TINK, primitives[0]->get_output_prefix_type());
+  }
+
+  {  // Check legacy primitive.
+    std::string prefix = CryptoFormat::GetOutputPrefix(key_2).value();
+    auto& primitives = *(primitive_set.get_primitives(prefix).value());
+    EXPECT_EQ(1, primitives.size());
+    EXPECT_EQ(DummyMac(mac_name_2).ComputeMac(data).value(),
+              primitives[0]->get_primitive().ComputeMac(data).value());
+    EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
+    EXPECT_EQ(key_2.key_id(), primitives[0]->get_key_id());
+    EXPECT_EQ(OutputPrefixType::LEGACY,
+              primitives[0]->get_output_prefix_type());
+  }
+}
+
+TEST_F(PrimitiveSetTest, PrimaryKeyWithIdCollisions) {
+  std::string mac_name_1 = "MAC#1";
+  std::string mac_name_2 = "MAC#2";
+
+  uint32_t key_id_1 = 1234543;
+  KeysetInfo::KeyInfo key_info_1;
+  key_info_1.set_key_id(key_id_1);
+  key_info_1.set_status(KeyStatusType::ENABLED);
+
+  uint32_t key_id_2 = key_id_1;  // same id as key_2
+  KeysetInfo::KeyInfo key_info_2;
+  key_info_2.set_key_id(key_id_2);
+  key_info_2.set_status(KeyStatusType::ENABLED);
+
+  {  // Test with RAW-keys.
+    std::unique_ptr<Mac> mac_1(new DummyMac(mac_name_1));
+    std::unique_ptr<Mac> mac_2(new DummyMac(mac_name_2));
+    key_info_1.set_output_prefix_type(OutputPrefixType::RAW);
+    key_info_2.set_output_prefix_type(OutputPrefixType::RAW);
+    PrimitiveSet<Mac>::Builder primitive_set_builder;
+
+    // Add the first primitive, and set it as primary.
+    primitive_set_builder.AddPrimaryPrimitive(std::move(mac_1), key_info_1);
+
+    auto primitive_set_result = std::move(primitive_set_builder).Build();
+    ASSERT_TRUE(primitive_set_result.ok()) << primitive_set_result.status();
+    PrimitiveSet<Mac> primitive_set = std::move(primitive_set_result.value());
+
+    std::string identifier = "";
+    const auto& primitives =
+        *(primitive_set.get_primitives(identifier).value());
+    EXPECT_EQ(1, primitives.size());
+    EXPECT_EQ(primitive_set.get_primary(), primitives[0].get());
+  }
+
+  {  // Test with TINK-keys.
+    std::unique_ptr<Mac> mac_1(new DummyMac(mac_name_1));
+    std::unique_ptr<Mac> mac_2(new DummyMac(mac_name_2));
+    key_info_1.set_output_prefix_type(OutputPrefixType::TINK);
+    key_info_2.set_output_prefix_type(OutputPrefixType::TINK);
+    PrimitiveSet<Mac>::Builder primitive_set_builder;
+
+    // Add the first primitive, and set it as primary.
+    primitive_set_builder.AddPrimaryPrimitive(std::move(mac_1), key_info_1);
+
+    auto primitive_set_result = std::move(primitive_set_builder).Build();
+    ASSERT_TRUE(primitive_set_result.ok()) << primitive_set_result.status();
+    PrimitiveSet<Mac> primitive_set = std::move(primitive_set_result.value());
+    std::string identifier = CryptoFormat::GetOutputPrefix(key_info_1).value();
+    const auto& primitives =
+        *(primitive_set.get_primitives(identifier).value());
+    EXPECT_EQ(1, primitives.size());
+    EXPECT_EQ(primitive_set.get_primary(), primitives[0].get());
+  }
+
+  {  // Test with LEGACY-keys.
+    std::unique_ptr<Mac> mac_1(new DummyMac(mac_name_1));
+    std::unique_ptr<Mac> mac_2(new DummyMac(mac_name_2));
+    key_info_1.set_output_prefix_type(OutputPrefixType::LEGACY);
+    key_info_2.set_output_prefix_type(OutputPrefixType::LEGACY);
+    PrimitiveSet<Mac>::Builder primitive_set_builder;
+
+    // Add the first primitive, and set it as primary.
+    primitive_set_builder.AddPrimaryPrimitive(std::move(mac_1), key_info_1);
+
+    auto primitive_set_result = std::move(primitive_set_builder).Build();
+    ASSERT_TRUE(primitive_set_result.ok()) << primitive_set_result.status();
+    PrimitiveSet<Mac> primitive_set = std::move(primitive_set_result.value());
+    std::string identifier = CryptoFormat::GetOutputPrefix(key_info_1).value();
+    const auto& primitives =
+        *(primitive_set.get_primitives(identifier).value());
+    EXPECT_EQ(1, primitives.size());
+    EXPECT_EQ(primitive_set.get_primary(), primitives[0].get());
+  }
+}
+
+TEST_F(PrimitiveSetTest, DisabledKey) {
+  std::string mac_name_1 = "MAC#1";
+  std::unique_ptr<Mac> mac_1(new DummyMac(mac_name_1));
+
+  uint32_t key_id_1 = 1234543;
+  KeysetInfo::KeyInfo key_info_1;
+  key_info_1.set_output_prefix_type(OutputPrefixType::TINK);
+  key_info_1.set_key_id(key_id_1);
+  key_info_1.set_status(KeyStatusType::DISABLED);
+
+  // Add all the primitives.
+  auto add_primitive_result = PrimitiveSet<Mac>::Builder{}
+                                  .AddPrimitive(std::move(mac_1), key_info_1)
+                                  .Build();
+  EXPECT_FALSE(add_primitive_result.ok());
+}
+
+KeysetInfo::KeyInfo CreateKey(uint32_t key_id,
+                              OutputPrefixType output_prefix_type,
+                              KeyStatusType key_status,
+                              absl::string_view type_url) {
+  KeysetInfo::KeyInfo key_info;
+  key_info.set_output_prefix_type(output_prefix_type);
+  key_info.set_key_id(key_id);
+  key_info.set_status(key_status);
+  std::string type_url_str(type_url);
+  key_info.set_type_url(type_url_str);
+  return key_info;
+}
+
+// Struct to hold MAC, Id and type_url.
+struct MacIdAndTypeUrl {
+  std::string mac;
+  std::string id;
+  std::string type_url;
+};
+
+bool operator==(const MacIdAndTypeUrl& first, const MacIdAndTypeUrl& other) {
+  return first.mac == other.mac && first.id == other.id &&
+         first.type_url == other.type_url;
+}
+
+TEST_F(PrimitiveSetTest, GetAll) {
+  auto pset_result =
+      PrimitiveSet<Mac>::Builder{}
+          .AddPrimitive(
+              absl::make_unique<DummyMac>("MAC1"),
+              CreateKey(0x01010101, OutputPrefixType::TINK,
+                        KeyStatusType::ENABLED, /*type_url=*/
+                        "type.googleapis.com/google.crypto.tink.HmacKey"))
+          .AddPrimitive(
+              absl::make_unique<DummyMac>("MAC2"),
+              CreateKey(0x02020202, OutputPrefixType::TINK,
+                        KeyStatusType::ENABLED, /*type_url=*/
+                        "type.googleapis.com/google.crypto.tink.HmacKey"))
+          // Add primitive and make it primary.
+          .AddPrimaryPrimitive(
+              absl::make_unique<DummyMac>("MAC3"),
+              CreateKey(0x02020202, OutputPrefixType::TINK,
+                        KeyStatusType::ENABLED, /*type_url=*/
+                        "type.googleapis.com/google.crypto.tink.AesCmacKey"))
+          .AddPrimitive(
+              absl::make_unique<DummyMac>("MAC4"),
+              CreateKey(0x02020202, OutputPrefixType::RAW,
+                        KeyStatusType::ENABLED, /*type_url=*/
+                        "type.googleapis.com/google.crypto.tink.AesCmacKey"))
+          .AddPrimitive(
+              absl::make_unique<DummyMac>("MAC5"),
+              CreateKey(0x01010101, OutputPrefixType::TINK,
+                        KeyStatusType::ENABLED, /*type_url=*/
+                        "type.googleapis.com/google.crypto.tink.AesCmacKey"))
+          .Build();
+
+  ASSERT_TRUE(pset_result.ok()) << pset_result.status();
+  PrimitiveSet<Mac> pset = std::move(pset_result.value());
+
+  std::vector<MacIdAndTypeUrl> mac_id_and_type;
+  for (auto* entry : pset.get_all()) {
+    auto mac_or = entry->get_primitive().ComputeMac("");
+    ASSERT_THAT(mac_or, IsOk());
+    mac_id_and_type.push_back({mac_or.value(), entry->get_identifier(),
+                               std::string(entry->get_key_type_url())});
+  }
+
+  // In the following id part, the first byte is 1 for Tink.
+  std::vector<MacIdAndTypeUrl> expected_result = {
+      {/*mac=*/"13:0:DummyMac:MAC1", /*id=*/absl::StrCat("\1\1\1\1\1"),
+       /*type_url=*/"type.googleapis.com/google.crypto.tink.HmacKey"},
+      {/*mac=*/"13:0:DummyMac:MAC2", /*id=*/absl::StrCat("\1\2\2\2\2"),
+       /*type_url=*/"type.googleapis.com/google.crypto.tink.HmacKey"},
+      {/*mac=*/"13:0:DummyMac:MAC3", /*id=*/absl::StrCat("\1\2\2\2\2"),
+       /*type_url=*/"type.googleapis.com/google.crypto.tink.AesCmacKey"},
+      {/*mac=*/"13:0:DummyMac:MAC4", /*id=*/"",
+       /*type_url=*/"type.googleapis.com/google.crypto.tink.AesCmacKey"},
+      {/*mac=*/"13:0:DummyMac:MAC5", /*id=*/absl::StrCat("\1\1\1\1\1"),
+       /*type_url=*/"type.googleapis.com/google.crypto.tink.AesCmacKey"}};
+
+  EXPECT_THAT(mac_id_and_type, UnorderedElementsAreArray(expected_result));
+}
+
+TEST_F(PrimitiveSetTest, LegacyConcurrentOperations) {
+  PrimitiveSet<Mac> mac_set;
+  int offset_a = 100;
+  int offset_b = 150;
+  int count = 100;
+
+  // Add some primitives.
+  std::thread add_primitives_a(
+      [&]() { add_primitives(&mac_set, offset_a, count); });
+  std::thread add_primitives_b(
+      [&]() { add_primitives(&mac_set, offset_b, count); });
+  add_primitives_a.join();
+  add_primitives_b.join();
+
+  // Access primitives.
+  std::thread access_primitives_a(access_primitives, &mac_set, offset_a, count);
+  std::thread access_primitives_b(access_primitives, &mac_set, offset_b, count);
+  access_primitives_a.join();
+  access_primitives_b.join();
+
+  // Verify the common key ids added by both threads.
+  for (int key_id = offset_a; key_id < offset_b + count; key_id++) {
+    KeysetInfo::KeyInfo key_info;
+    key_info.set_output_prefix_type(OutputPrefixType::TINK);
+    key_info.set_key_id(key_id);
+    key_info.set_status(KeyStatusType::ENABLED);
+    std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
+    auto get_result = mac_set.get_primitives(prefix);
+    EXPECT_TRUE(get_result.ok()) << get_result.status();
+    auto macs = get_result.value();
+    if (key_id >= offset_b && key_id < offset_a + count) {
+      EXPECT_EQ(2, macs->size());  // overlapping key_id range
+    } else {
+      EXPECT_EQ(1, macs->size());
+    }
+  }
+}
+
+TEST_F(PrimitiveSetTest, LegacyBasic) {
+  std::string mac_name_1 = "MAC#1";
+  std::unique_ptr<Mac> mac_1(new DummyMac(mac_name_1));
+  std::string mac_name_2 = "MAC#2";
+  std::unique_ptr<Mac> mac_2(new DummyMac(mac_name_2));
+  std::string mac_name_3 = "MAC#3";
+  std::unique_ptr<Mac> mac_3(new DummyMac(mac_name_3));
+  std::string mac_name_4 = "MAC#3";
+  std::unique_ptr<Mac> mac_4(new DummyMac(mac_name_4));
+  std::string mac_name_5 = "MAC#3";
+  std::unique_ptr<Mac> mac_5(new DummyMac(mac_name_5));
+  std::string mac_name_6 = "MAC#3";
+  std::unique_ptr<Mac> mac_6(new DummyMac(mac_name_6));
+
+  uint32_t key_id_1 = 1234543;
+  KeysetInfo::KeyInfo key_1;
+  key_1.set_output_prefix_type(OutputPrefixType::TINK);
+  key_1.set_key_id(key_id_1);
+  key_1.set_status(KeyStatusType::ENABLED);
+
+  uint32_t key_id_2 = 7213743;
+  KeysetInfo::KeyInfo key_2;
+  key_2.set_output_prefix_type(OutputPrefixType::LEGACY);
+  key_2.set_key_id(key_id_2);
+  key_2.set_status(KeyStatusType::ENABLED);
+
+  uint32_t key_id_3 = key_id_2;  // same id as key_2
   KeysetInfo::KeyInfo key_3;
   key_3.set_output_prefix_type(OutputPrefixType::TINK);
   key_3.set_key_id(key_id_3);
@@ -155,7 +516,7 @@ TEST_F(PrimitiveSetTest, Basic) {
   key_5.set_key_id(key_id_5);
   key_5.set_status(KeyStatusType::ENABLED);
 
-  uint32_t key_id_6 = key_id_1;    // same id as key_1
+  uint32_t key_id_6 = key_id_1;  // same id as key_1
   KeysetInfo::KeyInfo key_6;
   key_6.set_output_prefix_type(OutputPrefixType::TINK);
   key_6.set_key_id(key_id_6);
@@ -260,7 +621,7 @@ TEST_F(PrimitiveSetTest, Basic) {
   }
 }
 
-TEST_F(PrimitiveSetTest, PrimaryKeyWithIdCollisions) {
+TEST_F(PrimitiveSetTest, LegacyPrimaryKeyWithIdCollisions) {
   std::string mac_name_1 = "MAC#1";
   std::string mac_name_2 = "MAC#2";
 
@@ -269,7 +630,7 @@ TEST_F(PrimitiveSetTest, PrimaryKeyWithIdCollisions) {
   key_info_1.set_key_id(key_id_1);
   key_info_1.set_status(KeyStatusType::ENABLED);
 
-  uint32_t key_id_2 = key_id_1;    // same id as key_2
+  uint32_t key_id_2 = key_id_1;  // same id as key_2
   KeysetInfo::KeyInfo key_info_2;
   key_info_2.set_key_id(key_id_2);
   key_info_2.set_status(KeyStatusType::ENABLED);
@@ -362,7 +723,7 @@ TEST_F(PrimitiveSetTest, PrimaryKeyWithIdCollisions) {
   }
 }
 
-TEST_F(PrimitiveSetTest, DisabledKey) {
+TEST_F(PrimitiveSetTest, LegacyDisabledKey) {
   std::string mac_name_1 = "MAC#1";
   std::unique_ptr<Mac> mac_1(new DummyMac(mac_name_1));
 
@@ -379,32 +740,7 @@ TEST_F(PrimitiveSetTest, DisabledKey) {
   EXPECT_FALSE(add_primitive_result.ok());
 }
 
-KeysetInfo::KeyInfo CreateKey(uint32_t key_id,
-                              OutputPrefixType output_prefix_type,
-                              KeyStatusType key_status,
-                              absl::string_view type_url) {
-  KeysetInfo::KeyInfo key_info;
-  key_info.set_output_prefix_type(output_prefix_type);
-  key_info.set_key_id(key_id);
-  key_info.set_status(key_status);
-  std::string type_url_str(type_url);
-  key_info.set_type_url(type_url_str);
-  return key_info;
-}
-
-// Struct to hold MAC, Id and type_url.
-struct MacIdAndTypeUrl {
-  std::string mac;
-  std::string id;
-  std::string type_url;
-};
-
-bool operator==(const MacIdAndTypeUrl& first, const MacIdAndTypeUrl& other) {
-  return first.mac == other.mac && first.id == other.id &&
-         first.type_url == other.type_url;
-}
-
-TEST_F(PrimitiveSetTest, GetAll) {
+TEST_F(PrimitiveSetTest, LegacyGetAll) {
   PrimitiveSet<Mac> pset;
   EXPECT_THAT(
       pset.AddPrimitive(