TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-14 14:46:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update identity type name

Browse Source 
PiperOrigin-RevId: 629163344
This commit is contained in:
hai007
2024-04-29 13:12:45 -07:00
committed by Copybara-Service
parent 048e48e415
commit 0b04994f71
24 changed files with 136 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/platform/credential_storage_impl_test.cc
+18 -12
View File
@@ -67,8 +67,10 @@ SharedCredential CreatePublicCredential(absl::string_view secret_id,
std::vector<LocalCredential> BuildPrivateCreds(absl::string_view secret_id) {
std::vector<LocalCredential> private_credentials = {
CreateLocalCredential(secret_id, IdentityType::IDENTITY_TYPE_PRIVATE),
CreateLocalCredential(secret_id, IdentityType::IDENTITY_TYPE_TRUSTED),
CreateLocalCredential(secret_id,
IdentityType::IDENTITY_TYPE_PRIVATE_GROUP),
CreateLocalCredential(secret_id,
IdentityType::IDENTITY_TYPE_CONTACTS_GROUP),
CreateLocalCredential(secret_id,
IdentityType::IDENTITY_TYPE_PROVISIONED)};
return private_credentials;
@@ -76,8 +78,10 @@ std::vector<LocalCredential> BuildPrivateCreds(absl::string_view secret_id) {
std::vector<SharedCredential> BuildPublicCreds(absl::string_view secret_id) {
std::vector<SharedCredential> public_credentials = {
CreatePublicCredential(secret_id, IdentityType::IDENTITY_TYPE_PRIVATE),
CreatePublicCredential(secret_id, IdentityType::IDENTITY_TYPE_TRUSTED),
CreatePublicCredential(secret_id,
IdentityType::IDENTITY_TYPE_PRIVATE_GROUP),
CreatePublicCredential(secret_id,
IdentityType::IDENTITY_TYPE_CONTACTS_GROUP),
CreatePublicCredential(secret_id,
IdentityType::IDENTITY_TYPE_PROVISIONED)};
return public_credentials;
@@ -450,9 +454,10 @@ TEST_P(IdentityFilterTest, FilterLocalCredentialsByIdentityType) {
TEST_P(IdentityFilterTest, FilterLocalCredentialsFailsWhenNoCredentialsMatch) {
IdentityType identity_type = GetParam();
// Create a credential of a different identity type than the one we query.
IdentityType other_type = identity_type == IdentityType::IDENTITY_TYPE_PRIVATE
? IdentityType::IDENTITY_TYPE_TRUSTED
: IdentityType::IDENTITY_TYPE_PRIVATE;
IdentityType other_type =
identity_type == IdentityType::IDENTITY_TYPE_PRIVATE_GROUP
? IdentityType::IDENTITY_TYPE_CONTACTS_GROUP
: IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
std::vector<LocalCredential> private_creds = {
CreateLocalCredential(kSecretId, other_type)};
CredentialStorageImpl credential_storage;
@@ -486,9 +491,10 @@ TEST_P(IdentityFilterTest, FilterPublicCredentialsByIdentityType) {
TEST_P(IdentityFilterTest, FilterPublicCredentialsFailsWhenNoCredentialsMatch) {
IdentityType identity_type = GetParam();
// Create a credential of a different identity type than the one we query.
IdentityType other_type = identity_type == IdentityType::IDENTITY_TYPE_PRIVATE
? IdentityType::IDENTITY_TYPE_TRUSTED
: IdentityType::IDENTITY_TYPE_PRIVATE;
IdentityType other_type =
identity_type == IdentityType::IDENTITY_TYPE_PRIVATE_GROUP
? IdentityType::IDENTITY_TYPE_CONTACTS_GROUP
: IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
std::vector<SharedCredential> public_creds = {
CreatePublicCredential(kSecretId, other_type)};
CredentialStorageImpl credential_storage;
@@ -503,8 +509,8 @@ TEST_P(IdentityFilterTest, FilterPublicCredentialsFailsWhenNoCredentialsMatch) {
INSTANTIATE_TEST_SUITE_P(
CredentialStorageImplTest, IdentityFilterTest,
testing::Values(IdentityType::IDENTITY_TYPE_PRIVATE,
IdentityType::IDENTITY_TYPE_TRUSTED,
testing::Values(IdentityType::IDENTITY_TYPE_PRIVATE_GROUP,
IdentityType::IDENTITY_TYPE_CONTACTS_GROUP,
IdentityType::IDENTITY_TYPE_PROVISIONED));
} // namespace
internal/proto/credential.proto
+2 -2
View File
@@ -26,8 +26,8 @@ option optimize_for = LITE_RUNTIME;
// LINT.IfChange(IdentityType)
enum IdentityType {
IDENTITY_TYPE_UNSPECIFIED = 0;
IDENTITY_TYPE_PRIVATE = 1;
IDENTITY_TYPE_TRUSTED = 2;
IDENTITY_TYPE_PRIVATE_GROUP = 1;
IDENTITY_TYPE_CONTACTS_GROUP = 2;
IDENTITY_TYPE_PUBLIC = 3;
IDENTITY_TYPE_PROVISIONED = 4;
}
presence/credential_test.cc
+5 -5
View File
@@ -27,7 +27,7 @@ namespace presence {
namespace {
using ::nearby::internal::LocalCredential;
using ::nearby::internal::SharedCredential;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_PROVISIONED;
using ::protobuf_matchers::EqualsProto;
@@ -41,9 +41,9 @@ TEST(CredentialsTest, InitSharedCredential) {
SharedCredential pc1 = {};
SharedCredential pc2 = {};
EXPECT_THAT(pc1, EqualsProto(pc2));
pc1.set_identity_type(IDENTITY_TYPE_PRIVATE);
pc1.set_identity_type(IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_THAT(pc1, ::testing::Not(EqualsProto(pc2)));
pc2.set_identity_type(IDENTITY_TYPE_PRIVATE);
pc2.set_identity_type(IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_THAT(pc1, EqualsProto(pc2));
}
@@ -51,9 +51,9 @@ TEST(CredentialsTest, InitLocalCredential) {
LocalCredential pc1 = {};
LocalCredential pc2 = {};
EXPECT_THAT(pc1, EqualsProto(pc2));
pc1.set_identity_type(IDENTITY_TYPE_PRIVATE);
pc1.set_identity_type(IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_THAT(pc1, ::testing::Not(EqualsProto(pc2)));
pc2.set_identity_type(IDENTITY_TYPE_PRIVATE);
pc2.set_identity_type(IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_THAT(pc1, EqualsProto(pc2));
}
presence/data_element.h
+2 -2
View File
@@ -45,8 +45,8 @@ class DataElement {
// The field types listed below require special processing when generating and
// parsing NP advertisements.
static constexpr int kSaltFieldType = 0;
static constexpr int kPrivateIdentityFieldType = 1;
static constexpr int kTrustedIdentityFieldType = 2;
static constexpr int kPrivateGroupIdentityFieldType = 1;
static constexpr int kContactsGroupIdentityFieldType = 2;
static constexpr int kPublicIdentityFieldType = 3;
static constexpr int kProvisionedIdentityFieldType = 4;
static constexpr int kTxPowerFieldType = 5;
presence/discovery_filter_test.cc
+1 -1
View File
@@ -25,7 +25,7 @@ namespace {
using ::nearby::internal::IdentityType;
const PresenceAction kTestAction = {1};
const IdentityType kTestIdentity = {IdentityType::IDENTITY_TYPE_TRUSTED};
const IdentityType kTestIdentity = {IdentityType::IDENTITY_TYPE_CONTACTS_GROUP};
TEST(DiscoveryFilterTest, DefaultConstructorWorks) {
DiscoveryFilter filter;
presence/implementation/advertisement_decoder_impl.cc
+8 -8
View File
@@ -63,9 +63,9 @@ bool IsDataElementAllowed(uint8_t header) {
return length == 2;
case DataElement::kPublicIdentityFieldType:
return length == 0;
case DataElement::kPrivateIdentityFieldType:
case DataElement::kPrivateGroupIdentityFieldType:
case DataElement::kProvisionedIdentityFieldType:
case DataElement::kTrustedIdentityFieldType:
case DataElement::kContactsGroupIdentityFieldType:
return length >= 2 && length <= 6;
case DataElement::kTxPowerFieldType:
return length == 1;
@@ -87,8 +87,8 @@ bool IsDataElementAllowed(uint8_t header) {
}
bool IsEncryptedIdentity(int data_type) {
return data_type == DataElement::kPrivateIdentityFieldType ||
data_type == DataElement::kTrustedIdentityFieldType ||
return data_type == DataElement::kPrivateGroupIdentityFieldType ||
data_type == DataElement::kContactsGroupIdentityFieldType ||
data_type == DataElement::kProvisionedIdentityFieldType;
}
@@ -99,10 +99,10 @@ bool IsIdentity(int data_type) {
internal::IdentityType GetIdentityType(int data_type) {
switch (data_type) {
case DataElement::kPrivateIdentityFieldType:
return internal::IDENTITY_TYPE_PRIVATE;
case DataElement::kTrustedIdentityFieldType:
return internal::IDENTITY_TYPE_TRUSTED;
case DataElement::kPrivateGroupIdentityFieldType:
return internal::IDENTITY_TYPE_PRIVATE_GROUP;
case DataElement::kContactsGroupIdentityFieldType:
return internal::IDENTITY_TYPE_CONTACTS_GROUP;
case DataElement::kProvisionedIdentityFieldType:
return internal::IDENTITY_TYPE_PROVISIONED;
case DataElement::kPublicIdentityFieldType:
presence/implementation/advertisement_decoder_new_format_test.cc
+3 -2
View File
@@ -92,13 +92,14 @@ TEST(AdvertisementDecoderImpl, DecodeEncryptedAdvertisement) {
known_mac.AsStringView());
absl::flat_hash_map<IdentityType, std::vector<internal::SharedCredential>>
credentials;
credentials[IdentityType::IDENTITY_TYPE_PRIVATE].push_back(public_credential);
credentials[IdentityType::IDENTITY_TYPE_PRIVATE_GROUP].push_back(
public_credential);
AdvertisementDecoderImpl decoder = AdvertisementDecoderImpl(&credentials);
absl::StatusOr<Advertisement> result =
decoder.DecodeAdvertisement(absl::HexStringToBytes(V0AdvEncryptedBytes));
ASSERT_OK(result);
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_PRIVATE);
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_EQ(result->version, 0);
EXPECT_THAT(result->data_elements,
ElementsAre(DataElement(DataElement::kSaltFieldType,
presence/implementation/advertisement_decoder_rust_impl.cc
+4 -4
View File
@@ -50,8 +50,8 @@ AdvertisementDecoderImpl::InitializeCredentialBook(
}
nearby_protocol::CredentialSlab slab;
for (const auto& credential :
(*credentials_map)[internal::IdentityType::IDENTITY_TYPE_PRIVATE]) {
for (const auto& credential : (*credentials_map)
[internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP]) {
std::vector<uint8_t> metadata_bytes(
credential.encrypted_metadata_bytes_v0().begin(),
credential.encrypted_metadata_bytes_v0().end());
@@ -96,7 +96,7 @@ internal::IdentityType GetIdentityType(
case np_ffi::internal::DeserializedV0IdentityKind::Plaintext:
return internal::IdentityType::IDENTITY_TYPE_PUBLIC;
case np_ffi::internal::DeserializedV0IdentityKind::Decrypted:
return internal::IdentityType::IDENTITY_TYPE_PRIVATE;
return internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
}
}
@@ -112,7 +112,7 @@ absl::Status ProcessLegibleV0Adv(
// TODO(b/333126765): salt isn't a DE, we should restructure the Advertisement
// struct to reflect this
if (advertisement.identity_type ==
internal::IdentityType::IDENTITY_TYPE_PRIVATE) {
internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP) {
auto cred_details = payload.TryGetIdentityDetails();
if (!cred_details.ok()) {
return cred_details.status();
presence/implementation/advertisement_decoder_test.cc
+11 -11
View File
@@ -47,8 +47,8 @@ constexpr absl::string_view kAccountName = "test account";
ScanRequest GetScanRequest() {
return {.account_name = std::string(kAccountName),
.identity_types = {IdentityType::IDENTITY_TYPE_PRIVATE,
IdentityType::IDENTITY_TYPE_TRUSTED,
.identity_types = {IdentityType::IDENTITY_TYPE_PRIVATE_GROUP,
IdentityType::IDENTITY_TYPE_CONTACTS_GROUP,
IdentityType::IDENTITY_TYPE_PUBLIC,
IdentityType::IDENTITY_TYPE_PROVISIONED}};
}
@@ -58,8 +58,8 @@ ScanRequest GetScanRequest(std::vector<SharedCredential> credentials) {
credentials};
return ScanRequestBuilder()
.SetAccountName(kAccountName)
.AddIdentityType(IdentityType::IDENTITY_TYPE_PRIVATE)
.AddIdentityType(IdentityType::IDENTITY_TYPE_TRUSTED)
.AddIdentityType(IdentityType::IDENTITY_TYPE_PRIVATE_GROUP)
.AddIdentityType(IdentityType::IDENTITY_TYPE_CONTACTS_GROUP)
.AddIdentityType(IdentityType::IDENTITY_TYPE_PUBLIC)
.AddIdentityType(IdentityType::IDENTITY_TYPE_PROVISIONED)
.Build();
@@ -87,7 +87,7 @@ TEST(AdvertisementDecoderImpl, DecodeBaseNpPrivateAdvertisement) {
{205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
absl::flat_hash_map<IdentityType, std::vector<internal::SharedCredential>>
credentials;
credentials[IdentityType::IDENTITY_TYPE_PRIVATE].push_back(
credentials[IdentityType::IDENTITY_TYPE_PRIVATE_GROUP].push_back(
GetPublicCredential());
AdvertisementDecoderImpl decoder(&credentials);
@@ -95,7 +95,7 @@ TEST(AdvertisementDecoderImpl, DecodeBaseNpPrivateAdvertisement) {
absl::HexStringToBytes("00514142b8412efb0bc657ba514baf4d1b50ddc842cd1c"));
ASSERT_OK(result);
EXPECT_EQ(result->metadata_key, metadata_key.AsStringView());
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_PRIVATE);
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_THAT(result->data_elements,
ElementsAre(DataElement(DataElement::kSaltFieldType, salt),
DataElement(DataElement::kTxPowerFieldType,
@@ -112,7 +112,7 @@ TEST(AdvertisementDecoderImpl,
absl::flat_hash_map<IdentityType, std::vector<internal::SharedCredential>>
credentials;
credentials[IdentityType::IDENTITY_TYPE_PRIVATE].push_back(
credentials[IdentityType::IDENTITY_TYPE_PRIVATE_GROUP].push_back(
GetPublicCredential());
AdvertisementDecoderImpl decoder(&credentials);
@@ -120,7 +120,7 @@ TEST(AdvertisementDecoderImpl,
absl::HexStringToBytes("00514142b8412efb0bc657ba514baf4d1b50ddc842cd1c"));
ASSERT_OK(result);
EXPECT_EQ(result->metadata_key, metadata_key.AsStringView());
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_PRIVATE);
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_THAT(result->data_elements,
ElementsAre(DataElement(DataElement::kSaltFieldType, salt),
DataElement(DataElement::kTxPowerFieldType,
@@ -135,7 +135,7 @@ TEST(AdvertisementDecoderImpl, DecodeBaseNpTrustedAdvertisement) {
{205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
absl::flat_hash_map<IdentityType, std::vector<internal::SharedCredential>>
credentials;
credentials[IdentityType::IDENTITY_TYPE_TRUSTED].push_back(
credentials[IdentityType::IDENTITY_TYPE_CONTACTS_GROUP].push_back(
GetPublicCredential());
AdvertisementDecoderImpl decoder(&credentials);
@@ -143,7 +143,7 @@ TEST(AdvertisementDecoderImpl, DecodeBaseNpTrustedAdvertisement) {
absl::HexStringToBytes("0052414257a35c020f1c547d7e169303196d75da7118ba"));
ASSERT_OK(result);
EXPECT_EQ(result->metadata_key, metadata_key.AsStringView());
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_TRUSTED);
EXPECT_EQ(result->identity_type, IdentityType::IDENTITY_TYPE_CONTACTS_GROUP);
EXPECT_THAT(
result->data_elements,
UnorderedElementsAre(DataElement(DataElement::kSaltFieldType, salt),
@@ -187,7 +187,7 @@ TEST(AdvertisementDecoderImpl, InvalidEncryptedContent) {
{205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
absl::flat_hash_map<IdentityType, std::vector<internal::SharedCredential>>
credentials;
credentials[IdentityType::IDENTITY_TYPE_PRIVATE].push_back(
credentials[IdentityType::IDENTITY_TYPE_PRIVATE_GROUP].push_back(
GetPublicCredential());
AdvertisementDecoderImpl decoder(&credentials);
presence/implementation/advertisement_factory.cc
+6 -6
View File
@@ -66,10 +66,10 @@ absl::Status AppendDataElement(unsigned data_type,
uint8_t GetIdentityFieldType(IdentityType type) {
switch (type) {
case IdentityType::IDENTITY_TYPE_PRIVATE:
return DataElement::kPrivateIdentityFieldType;
case IdentityType::IDENTITY_TYPE_TRUSTED:
return DataElement::kTrustedIdentityFieldType;
case IdentityType::IDENTITY_TYPE_PRIVATE_GROUP:
return DataElement::kPrivateGroupIdentityFieldType;
case IdentityType::IDENTITY_TYPE_CONTACTS_GROUP:
return DataElement::kContactsGroupIdentityFieldType;
case IdentityType::IDENTITY_TYPE_PUBLIC:
return DataElement::kPublicIdentityFieldType;
case IdentityType::IDENTITY_TYPE_PROVISIONED:
@@ -94,8 +94,8 @@ std::string SerializeAction(const Action& action) {
}
bool RequiresCredentials(IdentityType identity_type) {
return identity_type == IdentityType::IDENTITY_TYPE_PRIVATE ||
identity_type == IdentityType::IDENTITY_TYPE_TRUSTED ||
return identity_type == IdentityType::IDENTITY_TYPE_PRIVATE_GROUP ||
identity_type == IdentityType::IDENTITY_TYPE_CONTACTS_GROUP ||
identity_type == IdentityType::IDENTITY_TYPE_PROVISIONED;
}
} // namespace
presence/implementation/advertisement_factory_test.cc
+3 -3
View File
@@ -59,7 +59,7 @@ LocalCredential CreateLocalCredential(IdentityType identity_type) {
TEST(AdvertisementFactory, CreateAdvertisementFromPrivateIdentity) {
std::string account_name = "Test account";
std::string salt = "AB";
constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PRIVATE;
constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
std::vector<DataElement> data_elements;
data_elements.emplace_back(ActionBit::kActiveUnlockAction);
Action action = ActionFactory::CreateAction(data_elements);
@@ -83,7 +83,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromPrivateIdentity) {
TEST(AdvertisementFactory, CreateAdvertisementFromTrustedIdentity) {
std::string account_name = "Test account";
std::string salt = "AB";
constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_TRUSTED;
constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_CONTACTS_GROUP;
std::vector<DataElement> data_elements;
data_elements.emplace_back(ActionBit::kActiveUnlockAction);
data_elements.emplace_back(ActionBit::kPresenceManagerAction);
@@ -152,7 +152,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromPublicIdentity) {
TEST(AdvertisementFactory, CreateAdvertisementFailsWhenSaltIsTooShort) {
std::string salt = "AB";
constexpr IdentityType kIdentity = internal::IDENTITY_TYPE_PRIVATE;
constexpr IdentityType kIdentity = internal::IDENTITY_TYPE_PRIVATE_GROUP;
std::vector<DataElement> data_elements;
data_elements.emplace_back(ActionBit::kActiveUnlockAction);
Action action = ActionFactory::CreateAction(data_elements);
presence/implementation/advertisement_filter_test.cc
+12 -12
View File
@@ -37,20 +37,20 @@ namespace {
TEST(AdvertisementFilter, MatchesScanFilterNoFilterPasses) {
std::vector<DataElement> adv = {
DataElement(DataElement::kPrivateIdentityFieldType, "payload")};
DataElement(DataElement::kPrivateGroupIdentityFieldType, "payload")};
ScanRequest empty_scan_request = {};
AdvertisementFilter adv_filter(empty_scan_request);
// A scan request without scan filters matches any advertisement
EXPECT_TRUE(adv_filter.MatchesScanFilter(
{.data_elements = {
DataElement(DataElement::kPrivateIdentityFieldType, "payload")}}));
{.data_elements = {DataElement(
DataElement::kPrivateGroupIdentityFieldType, "payload")}}));
EXPECT_TRUE(adv_filter.MatchesScanFilter({}));
}
TEST(AdvertisementFilter, MatchesPresenceScanFilter) {
std::vector<DataElement> adv = {
DataElement(DataElement::kPrivateIdentityFieldType, "payload")};
DataElement(DataElement::kPrivateGroupIdentityFieldType, "payload")};
DataElement model_id =
DataElement(DataElement::kModelIdFieldType, "model id");
DataElement salt = DataElement(DataElement::kSaltFieldType, "salt");
@@ -72,7 +72,7 @@ TEST(AdvertisementFilter, MatchesPresenceScanFilter) {
TEST(AdvertisementFilter, MatchesLegacyPresenceScanFilter) {
std::vector<DataElement> adv = {
DataElement(DataElement::kPrivateIdentityFieldType, "payload")};
DataElement(DataElement::kPrivateGroupIdentityFieldType, "payload")};
DataElement model_id =
DataElement(DataElement::kModelIdFieldType, "model id");
DataElement salt = DataElement(DataElement::kSaltFieldType, "salt");
@@ -95,14 +95,14 @@ TEST(AdvertisementFilter, MatchesLegacyPresenceScanFilter) {
TEST(AdvertisementFilter,
EncryptedIdentityFilterIgnoresPublicIdentityAdvertisement) {
AdvertisementFilter adv_filter(
{.identity_types = {internal::IdentityType::IDENTITY_TYPE_PRIVATE,
internal::IdentityType::IDENTITY_TYPE_TRUSTED,
{.identity_types = {internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP,
internal::IdentityType::IDENTITY_TYPE_CONTACTS_GROUP,
internal::IdentityType::IDENTITY_TYPE_PROVISIONED}});
EXPECT_FALSE(adv_filter.MatchesScanFilter(
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PUBLIC}));
EXPECT_TRUE(adv_filter.MatchesScanFilter(
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PRIVATE}));
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP}));
}
TEST(AdvertisementFilter, PublicIdentityFilterMatchesPublicIdentityAdv) {
@@ -112,7 +112,7 @@ TEST(AdvertisementFilter, PublicIdentityFilterMatchesPublicIdentityAdv) {
EXPECT_TRUE(adv_filter.MatchesScanFilter(
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PUBLIC}));
EXPECT_FALSE(adv_filter.MatchesScanFilter(
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PRIVATE}));
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP}));
}
TEST(AdvertisementFilter, EmptyIdentityFilterMatchesAllAdvIdentityTypes) {
@@ -121,12 +121,12 @@ TEST(AdvertisementFilter, EmptyIdentityFilterMatchesAllAdvIdentityTypes) {
EXPECT_TRUE(adv_filter.MatchesScanFilter(
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PUBLIC}));
EXPECT_TRUE(adv_filter.MatchesScanFilter(
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PRIVATE}));
{.identity_type = internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP}));
}
TEST(AdvertisementFilter, MatchesLegacyPresenceScanFilterWithActions) {
std::vector<DataElement> adv = {
DataElement(DataElement::kPrivateIdentityFieldType, "payload")};
DataElement(DataElement::kPrivateGroupIdentityFieldType, "payload")};
DataElement model_id =
DataElement(DataElement::kModelIdFieldType, "model id");
DataElement salt = DataElement(DataElement::kSaltFieldType, "salt");
@@ -147,7 +147,7 @@ TEST(AdvertisementFilter, MatchesLegacyPresenceScanFilterWithActions) {
TEST(AdvertisementFilter, MatchesMultipleFilters) {
std::vector<DataElement> adv = {
DataElement(DataElement::kPrivateIdentityFieldType, "payload")};
DataElement(DataElement::kPrivateGroupIdentityFieldType, "payload")};
DataElement model_id =
DataElement(DataElement::kModelIdFieldType, "model id");
DataElement salt = DataElement(DataElement::kSaltFieldType, "salt");
presence/implementation/broadcast_manager_test.cc
+1 -1
View File
@@ -162,7 +162,7 @@ TEST_P(BroadcastManagerTest, StartBroadcastPrivateIdentityFails) {
// TODO(b/256249404): Support private identity.
absl::StatusOr<BroadcastSessionId> session =
broadcast_manager_.StartBroadcast(
CreateBroadcastRequest(internal::IDENTITY_TYPE_PRIVATE),
CreateBroadcastRequest(internal::IDENTITY_TYPE_PRIVATE_GROUP),
CreateBroadcastCallback());
ASSERT_OK(session);
presence/implementation/credential_manager_impl_test.cc
+34 -31
View File
@@ -48,8 +48,8 @@ using ::nearby::internal::LocalCredential;
using ::nearby::internal::DeviceIdentityMetaData;
using ::nearby::internal::SharedCredential;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_TRUSTED;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_CONTACTS_GROUP;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
using ::protobuf_matchers::EqualsProto;
using ::testing::UnorderedPointwise;
using ::testing::status::StatusIs;
@@ -73,7 +73,7 @@ CredentialSelector BuildDefaultCredentialSelector() {
CredentialSelector credential_selector;
credential_selector.manager_app_id = std::string(kManagerAppId);
credential_selector.account_name = std::string(kAccountName);
credential_selector.identity_type = IDENTITY_TYPE_PRIVATE;
credential_selector.identity_type = IDENTITY_TYPE_PRIVATE_GROUP;
return credential_selector;
}
@@ -182,11 +182,12 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
constexpr absl::Time kEndTime = absl::FromUnixSeconds(200000);
auto credentials = credential_manager_.CreateLocalCredential(
device_identity_metadata, IDENTITY_TYPE_PRIVATE, kStartTime, kEndTime);
device_identity_metadata, IDENTITY_TYPE_PRIVATE_GROUP, kStartTime,
kEndTime);
LocalCredential private_credential = credentials.first;
// Verify the private credential.
EXPECT_EQ(private_credential.identity_type(), IDENTITY_TYPE_PRIVATE);
EXPECT_EQ(private_credential.identity_type(), IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_FALSE(private_credential.secret_id().empty());
EXPECT_EQ(private_credential.start_time_millis(),
absl::ToUnixMillis(kStartTime));
@@ -199,7 +200,7 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
SharedCredential public_credential = credentials.second;
// Verify the public credential.
EXPECT_EQ(public_credential.identity_type(), IDENTITY_TYPE_PRIVATE);
EXPECT_EQ(public_credential.identity_type(), IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_FALSE(public_credential.secret_id().empty());
EXPECT_EQ(private_credential.key_seed(), public_credential.key_seed());
EXPECT_LE(public_credential.start_time_millis(),
@@ -226,7 +227,7 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) {
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE_GROUP};
absl::Time previous_start_time;
absl::Time previous_end_time;
@@ -239,7 +240,7 @@ TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) {
for (int i = 0; i < kExpectedPresenceCredentialListSize; i++) {
SharedCredential& public_credential = public_credentials->at(i);
EXPECT_EQ(public_credential.identity_type(), IDENTITY_TYPE_PRIVATE);
EXPECT_EQ(public_credential.identity_type(), IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_FALSE(public_credential.secret_id().empty());
absl::Time start_time_millis =
absl::FromUnixMillis(public_credential.start_time_millis());
@@ -263,12 +264,12 @@ TEST_F(CredentialManagerImplTest,
SubscribeCallsCallbackWithExistingCredentials) {
absl::StatusOr<std::vector<SharedCredential>> public_credentials1;
absl::StatusOr<std::vector<SharedCredential>> public_credentials2;
AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE);
AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE_GROUP);
SubscriberId id1 = credential_manager_.SubscribeForPublicCredentials(
CredentialSelector{.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = IDENTITY_TYPE_PRIVATE},
.identity_type = IDENTITY_TYPE_PRIVATE_GROUP},
PublicCredentialType::kLocalPublicCredential,
{.credentials_fetched_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
@@ -277,7 +278,7 @@ TEST_F(CredentialManagerImplTest,
SubscriberId id2 = credential_manager_.SubscribeForPublicCredentials(
CredentialSelector{.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = IDENTITY_TYPE_PRIVATE},
.identity_type = IDENTITY_TYPE_PRIVATE_GROUP},
PublicCredentialType::kLocalPublicCredential,
{.credentials_fetched_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
@@ -302,7 +303,7 @@ TEST_F(CredentialManagerImplTest,
SubscriberId id = credential_manager_.SubscribeForPublicCredentials(
CredentialSelector{.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = IDENTITY_TYPE_PRIVATE},
.identity_type = IDENTITY_TYPE_PRIVATE_GROUP},
PublicCredentialType::kLocalPublicCredential,
{.credentials_fetched_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
@@ -311,7 +312,7 @@ TEST_F(CredentialManagerImplTest,
Fence();
EXPECT_THAT(public_credentials, StatusIs(absl::StatusCode::kUnknown));
AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE);
AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE_GROUP);
Fence();
ASSERT_OK(public_credentials);
@@ -326,7 +327,7 @@ TEST_F(CredentialManagerImplTest, NoCallbacksAfterUnsubscribe) {
SubscriberId id = credential_manager_.SubscribeForPublicCredentials(
CredentialSelector{.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = IDENTITY_TYPE_PRIVATE},
.identity_type = IDENTITY_TYPE_PRIVATE_GROUP},
PublicCredentialType::kLocalPublicCredential,
{.credentials_fetched_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
@@ -334,7 +335,7 @@ TEST_F(CredentialManagerImplTest, NoCallbacksAfterUnsubscribe) {
}});
credential_manager_.UnsubscribeFromPublicCredentials(id);
AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE);
AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE_GROUP);
Fence();
EXPECT_THAT(public_credentials, StatusIs(absl::StatusCode::kUnknown));
@@ -357,7 +358,7 @@ TEST_F(CredentialManagerImplTest,
}));
credential_manager_ =
CredentialManagerImpl(&executor_, std::move(credential_storage_ptr));
std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE_GROUP};
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identityTypes,
@@ -370,7 +371,7 @@ TEST_F(CredentialManagerImplTest,
TEST_F(CredentialManagerImplTest, UpdateRemotePublicCredentialsSuccessfully) {
SharedCredential public_credential_for_test;
public_credential_for_test.set_identity_type(
IdentityType::IDENTITY_TYPE_TRUSTED);
IdentityType::IDENTITY_TYPE_CONTACTS_GROUP);
std::vector<SharedCredential> public_credentials{
{public_credential_for_test}};
@@ -396,7 +397,7 @@ TEST_F(CredentialManagerImplTest,
absl::StatusOr<std::vector<SharedCredential>> subscribed_credentials;
SharedCredential public_credential_for_test;
public_credential_for_test.set_identity_type(
IdentityType::IDENTITY_TYPE_PRIVATE);
IdentityType::IDENTITY_TYPE_PRIVATE_GROUP);
std::vector<SharedCredential> public_credentials{
{public_credential_for_test}};
nearby::CountDownLatch updated_latch(1);
@@ -409,18 +410,20 @@ TEST_F(CredentialManagerImplTest,
},
};
SubscriberId id1 = credential_manager_.SubscribeForPublicCredentials(
CredentialSelector{.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = internal::IDENTITY_TYPE_PRIVATE},
CredentialSelector{
.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = internal::IDENTITY_TYPE_PRIVATE_GROUP},
PublicCredentialType::kRemotePublicCredential,
{.credentials_fetched_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
subscribed_credentials = std::move(credentials);
}});
SubscriberId id2 = credential_manager_.SubscribeForPublicCredentials(
CredentialSelector{.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = internal::IDENTITY_TYPE_TRUSTED},
CredentialSelector{
.manager_app_id = std::string(kManagerAppId),
.account_name = std::string(kAccountName),
.identity_type = internal::IDENTITY_TYPE_CONTACTS_GROUP},
PublicCredentialType::kRemotePublicCredential,
{.credentials_fetched_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
@@ -474,7 +477,7 @@ TEST_F(CredentialManagerImplTest, GetPublicCredentialsFailed) {
TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) {
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE_GROUP};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials = GenerateCredentialsSync(
@@ -499,7 +502,7 @@ TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) {
[](absl::string_view metadata_encryption_key,
absl::string_view key_seed,
absl::string_view metadata_string) { return ""; }));
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE_GROUP};
CountDownLatch latch(1);
credential_manager_ptr->GenerateCredentials(
@@ -520,8 +523,8 @@ TEST_F(CredentialManagerImplTest, UpdateLocalCredential) {
constexpr uint16_t kSalt = 1000;
absl::Status update_status = absl::UnknownError("");
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE,
IDENTITY_TYPE_TRUSTED};
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE_GROUP,
IDENTITY_TYPE_CONTACTS_GROUP};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identity_types,
@@ -578,7 +581,7 @@ TEST_F(CredentialManagerImplTest, EncryptAndDecryptDeviceIdentityMetaData) {
TEST_F(CredentialManagerImplTest, RefillCredentialsInGetLocalCredentials) {
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE_GROUP};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials = GenerateCredentialsSync(
@@ -596,7 +599,7 @@ TEST_F(CredentialManagerImplTest, RefillCredentialsInGetLocalCredentials) {
TEST_F(CredentialManagerImplTest, RefillCredentialsInGetSharedCredentials) {
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE_GROUP};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials = GenerateCredentialsSync(
@@ -616,7 +619,7 @@ TEST_F(CredentialManagerImplTest, RefillCredentialsInGetSharedCredentials) {
TEST_F(CredentialManagerImplTest, RefillExpiredCredsInGetLocal) {
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE_GROUP};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials = GenerateCredentialsSync(
presence/implementation/mediums/ble_test.cc
+1 -1
View File
@@ -58,7 +58,7 @@ class BleTest : public testing::TestWithParam<FeatureFlags> {
std::string account_name_ = "Test-Name";
constexpr static PowerMode kPowerMode = PowerMode::kBalanced;
std::vector<nearby::internal::IdentityType> identity_types_ = {
nearby::internal::IdentityType::IDENTITY_TYPE_TRUSTED,
nearby::internal::IdentityType::IDENTITY_TYPE_CONTACTS_GROUP,
};
std::vector<DataElement> extended_properties_ = {
DataElement{DataElement::kTxPowerFieldType, "-10"}};
presence/implementation/scan_manager.cc
+2 -2
View File
@@ -143,8 +143,8 @@ void ScanManager::NotifyFoundBle(ScanSessionId id, BleAdvertisementData data,
std::vector<CredentialSelector> GetCredentialSelectors(
const ScanRequest& scan_request) {
std::vector<nearby::internal::IdentityType> all_types = {
nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE,
nearby::internal::IdentityType::IDENTITY_TYPE_TRUSTED,
nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP,
nearby::internal::IdentityType::IDENTITY_TYPE_CONTACTS_GROUP,
nearby::internal::IdentityType::IDENTITY_TYPE_PUBLIC,
nearby::internal::IdentityType::IDENTITY_TYPE_PROVISIONED};
std::vector<CredentialSelector> selectors;
presence/implementation/scan_manager_test.cc
+4 -3
View File
@@ -388,7 +388,7 @@ TEST_F(ScanManagerTest, ScanningE2EWithEncryptedAdvertisementAndCredentials) {
nearby::BluetoothAdapter server_adapter;
Ble ble2(server_adapter);
PresenceBroadcast::BroadcastSection section = {
.identity = internal::IdentityType::IDENTITY_TYPE_PRIVATE,
.identity = internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP,
.extended_properties = MakeDefaultExtendedProperties(),
.account_name = "Test account"};
PresenceBroadcast presence_request = {.sections = {section}};
@@ -399,7 +399,8 @@ TEST_F(ScanManagerTest, ScanningE2EWithEncryptedAdvertisementAndCredentials) {
absl::StatusOr<AdvertisementData> advertisement =
AdvertisementFactory().CreateAdvertisement(
request.value(),
CreateLocalCredential(internal::IdentityType::IDENTITY_TYPE_PRIVATE));
CreateLocalCredential(
internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP));
EXPECT_OK(advertisement);
std::unique_ptr<AdvertisingSession> session = ble2.StartAdvertising(
advertisement.value(), PowerMode::kLowPower,
@@ -408,7 +409,7 @@ TEST_F(ScanManagerTest, ScanningE2EWithEncryptedAdvertisementAndCredentials) {
auto scan_request = MakeDefaultScanRequest();
scan_request.identity_types = {
nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE};
nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP};
// Start scanning
ScanSessionId scan_session =
presence/implementation/service_controller_impl_test.cc
+1 -1
View File
@@ -47,7 +47,7 @@ CredentialSelector BuildDefaultCredentialSelector() {
credential_selector.manager_app_id = std::string(kManagerAppId);
credential_selector.account_name = std::string(kAccountName);
credential_selector.identity_type =
::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE;
::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
return credential_selector;
}
presence/presence_device.cc
+6 -6
View File
@@ -39,8 +39,8 @@ constexpr char kEndpointIdChars[] = {
// LINT.IfChange
constexpr int kAndroidIdentityTypeUnknown = -1;
constexpr int kAndroidIdentityTypePrivate = 0;
constexpr int kAndroidIdentityTypeTrusted = 1;
constexpr int kAndroidIdentityTypePrivateGroup = 0;
constexpr int kAndroidIdentityTypeContactsGroup = 1;
constexpr int kAndroidIdentityTypePublic = 2;
// LINT.ThenChange(
// //depot/google3/java/com/google/android/gmscore/integ/client/nearby/src/com/google/android/gms/nearby/presence/PresenceIdentity.java
@@ -79,10 +79,10 @@ ConvertToConnectionsDeviceType(internal::DeviceType device_type) {
int ConvertToAndroidIdentityType(nearby::internal::IdentityType identity_type) {
switch (identity_type) {
case internal::IDENTITY_TYPE_PRIVATE:
return kAndroidIdentityTypePrivate;
case internal::IDENTITY_TYPE_TRUSTED:
return kAndroidIdentityTypeTrusted;
case internal::IDENTITY_TYPE_PRIVATE_GROUP:
return kAndroidIdentityTypePrivateGroup;
case internal::IDENTITY_TYPE_CONTACTS_GROUP:
return kAndroidIdentityTypeContactsGroup;
case internal::IDENTITY_TYPE_PUBLIC:
return kAndroidIdentityTypePublic;
default:
presence/presence_device_provider.cc
+4 -6
View File
@@ -123,10 +123,9 @@ AuthenticationStatus PresenceDeviceProvider::AuthenticateAsInitiator(
// unknown result to callers in NC.
service_controller_.GetLocalCredentials(
/*credential_selector=*/{.manager_app_id = manager_app_id_,
.account_name =
"dummy_account_name",
.account_name = "dummy_account_name",
.identity_type = ::nearby::internal::
IdentityType::IDENTITY_TYPE_PRIVATE},
IdentityType::IDENTITY_TYPE_PRIVATE_GROUP},
/*callback=*/{.credentials_fetched_cb = [this, &response, &remote_device,
&authentication_transport,
&shared_secret](
@@ -225,10 +224,9 @@ bool PresenceDeviceProvider::ReadAndVerifyRemoteDeviceData(
Future<bool> read_and_verify_result;
service_controller_.GetLocalPublicCredentials(
/*credential_selector=*/{.manager_app_id = manager_app_id_,
.account_name =
"dummy_account_name",
.account_name = "dummy_account_name",
.identity_type = ::nearby::internal::
IdentityType::IDENTITY_TYPE_PRIVATE},
IdentityType::IDENTITY_TYPE_PRIVATE_GROUP},
/*callback=*/{.credentials_fetched_cb = [this, &read_and_verify_result,
&authentication_transport,
&shared_secret](
presence/presence_device_test.cc
+3 -3
View File
@@ -88,9 +88,9 @@ TEST(PresenceDeviceTest, ExplicitInitNotEquals) {
PresenceDevice device1 =
PresenceDevice({kDefaultMotionType}, device_identity_metadata,
internal::IDENTITY_TYPE_PUBLIC);
PresenceDevice device2 =
PresenceDevice({kDefaultMotionType, kTestConfidence},
device_identity_metadata, internal::IDENTITY_TYPE_PRIVATE);
PresenceDevice device2 = PresenceDevice(
{kDefaultMotionType, kTestConfidence}, device_identity_metadata,
internal::IDENTITY_TYPE_PRIVATE_GROUP);
EXPECT_NE(device1, device2);
}
presence/presence_identity_test.cc
+2 -1
View File
@@ -22,7 +22,8 @@ namespace presence {
namespace {
using ::nearby::internal::IdentityType;
constexpr IdentityType kTestIdentityType = IdentityType::IDENTITY_TYPE_TRUSTED;
constexpr IdentityType kTestIdentityType =
IdentityType::IDENTITY_TYPE_CONTACTS_GROUP;
TEST(PresenceIdentityTest, ExplicitInitEquals) {
IdentityType identity1 = {kTestIdentityType};
presence/presence_service_test.cc
+2 -2
View File
@@ -56,7 +56,7 @@ CredentialSelector BuildDefaultCredentialSelector() {
CredentialSelector credential_selector;
credential_selector.manager_app_id = std::string(kManagerAppId);
credential_selector.account_name = std::string(kAccountName);
credential_selector.identity_type = internal::IDENTITY_TYPE_PRIVATE;
credential_selector.identity_type = internal::IDENTITY_TYPE_PRIVATE_GROUP;
return credential_selector;
}
@@ -126,7 +126,7 @@ TEST_F(PresenceServiceTest, TestUpdateRemotePublicCredentials) {
PresenceServiceImpl presence_service;
internal::SharedCredential public_credential_for_test;
public_credential_for_test.set_identity_type(
internal::IdentityType::IDENTITY_TYPE_TRUSTED);
internal::IdentityType::IDENTITY_TYPE_CONTACTS_GROUP);
std::vector<internal::SharedCredential> public_credentials{
{public_credential_for_test}};
presence/scan_request_builder_test.cc
+1 -1
View File
@@ -33,7 +33,7 @@ using ::nearby::internal::IdentityType;
constexpr absl::string_view kAccountName = "Google User";
constexpr bool kUseBle = true;
constexpr bool kOnlyScreenOnScan = true;
const IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PRIVATE;
const IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PRIVATE_GROUP;
const ScanType kScanType = ScanType::kPresenceScan;
const PowerMode powerMode = PowerMode::kLowLatency;
constexpr absl::string_view kManagerAppId = "Google App Manager";