libs/binder/tests/binderObserverConfigUnitTest.cpp - platform/frameworks/native - Git at Google

 /*
  * Copyright (C) 2025 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include <codecvt>
 #include <locale>
 #include <map>

 #include "../BinderObserverConfig.h"

 namespace android {

 using ::testing::_;
 using ::testing::Return;

 class BinderObserverConfigTest : public ::testing::Test {
 protected:
     class MockEnvironment : public BinderObserverConfig::Environment {
     public:
         MOCK_METHOD(std::string, readFileLine, (const std::string& path), (override));
         MOCK_METHOD(uid_t, getUid, (), (override));
         MOCK_METHOD(std::string, getProcessName, (), (override));
         MOCK_METHOD(BinderObserverConfig::ShardingConfig, getSystemServerSharding, (), (override));
         MOCK_METHOD(BinderObserverConfig::ShardingConfig, getOtherProcessesSharding, (),
                     (override));
         MOCK_METHOD(size_t, hashString8, (const std::string& content), (override));
         MOCK_METHOD(size_t, hashString16, (const std::u16string_view& content), (override));
     };

     const std::string kBootIdPath = "/proc/sys/kernel/random/boot_id";
     const std::string kProcessOffsetToken = "16e12b27-2a84-4355"; // used for process offset
     const std::string kAidlOffsetToken = "-84cd-948348d6c998";    // used for aidl offset
     const std::string kOtherProcessName = "some_other_process";   // used for aidl offset

     static constexpr BinderObserverConfig::ShardingConfig kMonitorEverythingSharding = {
             .processMod = 1,
             .spamMod = 1,
             .callMod = 1,
     };

     static constexpr BinderObserverConfig::ShardingConfig kSometimesEverythingSharding = {
             .processMod = 2,
             .spamMod = 1,
             .callMod = 1,
     };

     static constexpr BinderObserverConfig::ShardingConfig kModerateSharding = {
             .processMod = 55,
             .spamMod = 11,
             .callMod = 22,
     };

     static constexpr BinderObserverConfig::ShardingConfig kOnlySpamSharding = {
             .processMod = 100,
             .spamMod = 33,
             .callMod = 0,
     };

     static constexpr BinderObserverConfig::ShardingConfig kMonitorNothingSharding = {
             .processMod = 0,
             .spamMod = 0,
             .callMod = 0,
     };

     static std::unique_ptr<BinderObserverConfig> createConfig(
             BinderObserverConfig::Environment* environment) {
         return BinderObserverConfig::createConfig(
                 std::unique_ptr<BinderObserverConfig::Environment>(environment));
     }

     void SetUp() override {
         // Note: this should be owned (and destroyed) by the config class under test.
         mEnv = new MockEnvironment();
         ON_CALL(*mEnv, readFileLine(kBootIdPath))
                 .WillByDefault(Return(kProcessOffsetToken + kAidlOffsetToken));
         ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(5678));
         ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(6789));
     }

     // Configure mEnv so that the created config will be enabled/disabled (if possible)
     void setUpForSharding(BinderObserverConfig::ShardingConfig sharding, bool enabled = true) {
         EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
         EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
         ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));

         // Make the process hash such that the total is divisible by processMod.
         size_t processHash = sharding.processMod != 0
                 ? sharding.processMod - ((123 + 234) % sharding.processMod)
                 : 345; // impossible, will be disabled
         if (!enabled) {
             // If we don't want it to be enabled, change it so that the mod is not zero
             ++processHash;
         }

         ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(processHash));

         EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(sharding));
     }

     MockEnvironment* mEnv;
 };

 TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessMonitorEverything) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
     EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kMonitorEverythingSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // Since processMod 1 it should be enabled
     EXPECT_TRUE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessMonitorNothing) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
     EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kMonitorNothingSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // Since processMod is 0 it should be disabled
     EXPECT_FALSE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessEnabledByHash) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(303)); // process hash
     EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kModerateSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // the resulting token should be (123 + 234 + 303) % 55 = 0, so enabled
     EXPECT_TRUE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessDisabledByHash) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
     EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kModerateSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // the resulting token should be (123 + 234 + 345) % 55 = 42, so not enabled
     EXPECT_FALSE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, CreateConfigSystemServerEnabledByHash) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(1000));
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("system_server"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("system_server")).WillByDefault(Return(306)); // process hash
     EXPECT_CALL(*mEnv, getSystemServerSharding()).WillOnce(Return(kModerateSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // the resulting token should be (1000 + 234 + 306) % 55 = 0, so enabled
     EXPECT_TRUE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, CreateConfigSystemServerDisabledByHash) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(1000));
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("system_server"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("system_server")).WillByDefault(Return(345)); // process hash
     EXPECT_CALL(*mEnv, getSystemServerSharding()).WillOnce(Return(kModerateSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // the resulting token should be (1000 + 234 + 345) % 55 = 39, so not enabled
     EXPECT_FALSE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, CreateConfigFakeSystemServer) {
     EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123)); // not the right uid
     EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("system_server"));
     ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
     ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
     ON_CALL(*mEnv, getSystemServerSharding()).WillByDefault(Return(kMonitorEverythingSharding));
     EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kMonitorNothingSharding));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // Not enabled because it is not the real system_server.
     EXPECT_FALSE(config->isEnabled());
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoModerateShardingNotTracked) {
     setUpForSharding(kModerateSharding);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2345));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have ensured we have enabled config.
     EXPECT_TRUE(config->isEnabled());

     // spam: (1234 + 2345 + 21) % 11 = 3
     // calls: (1234 + 2345 + 21) % 22 = 14

     BinderObserverConfig::TrackingInfo expected = {.trackSpam = false, .trackLatency = false};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoModerateShardingTrackSpamOnly) {
     setUpForSharding(kModerateSharding);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2342));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have ensured we have enabled config.
     EXPECT_TRUE(config->isEnabled());

     // spam: (1234 + 2342 + 21) % 11 = 0
     // calls: (1234 + 2342 + 21) % 22 = 11
     BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = false};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoModerateShardingTrackSpamAndCalls) {
     setUpForSharding(kModerateSharding);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2331));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have ensured we have enabled config.
     EXPECT_TRUE(config->isEnabled());

     // spam: (1234 + 2331 + 21) % 11 = 0
     // calls: (1234 + 2331 + 21) % 22 = 0

     BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = true};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoMonitorEverythingShardingTrackSpamAndCalls) {
     setUpForSharding(kMonitorEverythingSharding);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2345));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have ensured we have enabled config.
     EXPECT_TRUE(config->isEnabled());

     // The numbers should not matter, everything should be monitored

     BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = true};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoMonitorNothingShardingTrackNothing) {
     setUpForSharding(kMonitorNothingSharding);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2345));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have ensured we have disiabled config.
     EXPECT_FALSE(config->isEnabled());

     // The numbers should not matter, nothing should be monitored

     BinderObserverConfig::TrackingInfo expected = {.trackSpam = false, .trackLatency = false};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoSometimesEverythingShardingTrackNothing) {
     setUpForSharding(kSometimesEverythingSharding, false);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2345));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have created a disabled config
     EXPECT_FALSE(config->isEnabled());

     // The numbers should not matter, nothing should be tracked because we are disabled

     BinderObserverConfig::TrackingInfo expected = {.trackSpam = false, .trackLatency = false};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 TEST_F(BinderObserverConfigTest, GetTrackingInfoOnlySpamShardingTrackSpam) {
     setUpForSharding(kOnlySpamSharding);

     ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
     ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
             .WillByDefault(Return(2342));

     std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

     // setUpForSharding should have created an enabled config
     EXPECT_TRUE(config->isEnabled());

     // spam: (1234 + 2342 + 21) % 33 = 0
     // calls: the numbers don't matter since callMod is 0

     BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = false};
     EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
 }

 } // namespace android
	/*
	* Copyright (C) 2025 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include <codecvt>
	#include <locale>
	#include <map>

	#include "../BinderObserverConfig.h"

	namespace android {

	using ::testing::_;
	using ::testing::Return;

	class BinderObserverConfigTest : public ::testing::Test {
	protected:
	class MockEnvironment : public BinderObserverConfig::Environment {
	public:
	MOCK_METHOD(std::string, readFileLine, (const std::string& path), (override));
	MOCK_METHOD(uid_t, getUid, (), (override));
	MOCK_METHOD(std::string, getProcessName, (), (override));
	MOCK_METHOD(BinderObserverConfig::ShardingConfig, getSystemServerSharding, (), (override));
	MOCK_METHOD(BinderObserverConfig::ShardingConfig, getOtherProcessesSharding, (),
	(override));
	MOCK_METHOD(size_t, hashString8, (const std::string& content), (override));
	MOCK_METHOD(size_t, hashString16, (const std::u16string_view& content), (override));
	};

	const std::string kBootIdPath = "/proc/sys/kernel/random/boot_id";
	const std::string kProcessOffsetToken = "16e12b27-2a84-4355"; // used for process offset
	const std::string kAidlOffsetToken = "-84cd-948348d6c998"; // used for aidl offset
	const std::string kOtherProcessName = "some_other_process"; // used for aidl offset

	static constexpr BinderObserverConfig::ShardingConfig kMonitorEverythingSharding = {
	.processMod = 1,
	.spamMod = 1,
	.callMod = 1,
	};

	static constexpr BinderObserverConfig::ShardingConfig kSometimesEverythingSharding = {
	.processMod = 2,
	.spamMod = 1,
	.callMod = 1,
	};

	static constexpr BinderObserverConfig::ShardingConfig kModerateSharding = {
	.processMod = 55,
	.spamMod = 11,
	.callMod = 22,
	};

	static constexpr BinderObserverConfig::ShardingConfig kOnlySpamSharding = {
	.processMod = 100,
	.spamMod = 33,
	.callMod = 0,
	};

	static constexpr BinderObserverConfig::ShardingConfig kMonitorNothingSharding = {
	.processMod = 0,
	.spamMod = 0,
	.callMod = 0,
	};

	static std::unique_ptr<BinderObserverConfig> createConfig(
	BinderObserverConfig::Environment* environment) {
	return BinderObserverConfig::createConfig(
	std::unique_ptr<BinderObserverConfig::Environment>(environment));
	}

	void SetUp() override {
	// Note: this should be owned (and destroyed) by the config class under test.
	mEnv = new MockEnvironment();
	ON_CALL(*mEnv, readFileLine(kBootIdPath))
	.WillByDefault(Return(kProcessOffsetToken + kAidlOffsetToken));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(5678));
	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(6789));
	}

	// Configure mEnv so that the created config will be enabled/disabled (if possible)
	void setUpForSharding(BinderObserverConfig::ShardingConfig sharding, bool enabled = true) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));

	// Make the process hash such that the total is divisible by processMod.
	size_t processHash = sharding.processMod != 0
	? sharding.processMod - ((123 + 234) % sharding.processMod)
	: 345; // impossible, will be disabled
	if (!enabled) {
	// If we don't want it to be enabled, change it so that the mod is not zero
	++processHash;
	}

	ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(processHash));

	EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(sharding));
	}

	MockEnvironment* mEnv;
	};

	TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessMonitorEverything) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
	EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kMonitorEverythingSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// Since processMod 1 it should be enabled
	EXPECT_TRUE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessMonitorNothing) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
	EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kMonitorNothingSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// Since processMod is 0 it should be disabled
	EXPECT_FALSE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessEnabledByHash) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(303)); // process hash
	EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kModerateSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// the resulting token should be (123 + 234 + 303) % 55 = 0, so enabled
	EXPECT_TRUE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, CreateConfigOtherProcessDisabledByHash) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("other_process"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
	EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kModerateSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// the resulting token should be (123 + 234 + 345) % 55 = 42, so not enabled
	EXPECT_FALSE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, CreateConfigSystemServerEnabledByHash) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(1000));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("system_server"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("system_server")).WillByDefault(Return(306)); // process hash
	EXPECT_CALL(*mEnv, getSystemServerSharding()).WillOnce(Return(kModerateSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// the resulting token should be (1000 + 234 + 306) % 55 = 0, so enabled
	EXPECT_TRUE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, CreateConfigSystemServerDisabledByHash) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(1000));
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("system_server"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("system_server")).WillByDefault(Return(345)); // process hash
	EXPECT_CALL(*mEnv, getSystemServerSharding()).WillOnce(Return(kModerateSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// the resulting token should be (1000 + 234 + 345) % 55 = 39, so not enabled
	EXPECT_FALSE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, CreateConfigFakeSystemServer) {
	EXPECT_CALL(*mEnv, getUid()).WillOnce(Return(123)); // not the right uid
	EXPECT_CALL(*mEnv, getProcessName()).WillOnce(Return("system_server"));
	ON_CALL(*mEnv, hashString8(kProcessOffsetToken)).WillByDefault(Return(234));
	ON_CALL(*mEnv, hashString8("other_process")).WillByDefault(Return(345)); // process hash
	ON_CALL(*mEnv, getSystemServerSharding()).WillByDefault(Return(kMonitorEverythingSharding));
	EXPECT_CALL(*mEnv, getOtherProcessesSharding()).WillOnce(Return(kMonitorNothingSharding));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// Not enabled because it is not the real system_server.
	EXPECT_FALSE(config->isEnabled());
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoModerateShardingNotTracked) {
	setUpForSharding(kModerateSharding);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2345));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have ensured we have enabled config.
	EXPECT_TRUE(config->isEnabled());

	// spam: (1234 + 2345 + 21) % 11 = 3
	// calls: (1234 + 2345 + 21) % 22 = 14

	BinderObserverConfig::TrackingInfo expected = {.trackSpam = false, .trackLatency = false};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoModerateShardingTrackSpamOnly) {
	setUpForSharding(kModerateSharding);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2342));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have ensured we have enabled config.
	EXPECT_TRUE(config->isEnabled());

	// spam: (1234 + 2342 + 21) % 11 = 0
	// calls: (1234 + 2342 + 21) % 22 = 11
	BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = false};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoModerateShardingTrackSpamAndCalls) {
	setUpForSharding(kModerateSharding);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2331));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have ensured we have enabled config.
	EXPECT_TRUE(config->isEnabled());

	// spam: (1234 + 2331 + 21) % 11 = 0
	// calls: (1234 + 2331 + 21) % 22 = 0

	BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = true};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoMonitorEverythingShardingTrackSpamAndCalls) {
	setUpForSharding(kMonitorEverythingSharding);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2345));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have ensured we have enabled config.
	EXPECT_TRUE(config->isEnabled());

	// The numbers should not matter, everything should be monitored

	BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = true};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoMonitorNothingShardingTrackNothing) {
	setUpForSharding(kMonitorNothingSharding);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2345));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have ensured we have disiabled config.
	EXPECT_FALSE(config->isEnabled());

	// The numbers should not matter, nothing should be monitored

	BinderObserverConfig::TrackingInfo expected = {.trackSpam = false, .trackLatency = false};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoSometimesEverythingShardingTrackNothing) {
	setUpForSharding(kSometimesEverythingSharding, false);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2345));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have created a disabled config
	EXPECT_FALSE(config->isEnabled());

	// The numbers should not matter, nothing should be tracked because we are disabled

	BinderObserverConfig::TrackingInfo expected = {.trackSpam = false, .trackLatency = false};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	TEST_F(BinderObserverConfigTest, GetTrackingInfoOnlySpamShardingTrackSpam) {
	setUpForSharding(kOnlySpamSharding);

	ON_CALL(*mEnv, hashString8(kAidlOffsetToken)).WillByDefault(Return(1234));
	ON_CALL(*mEnv, hashString16(std::u16string_view(u"IContentProvider")))
	.WillByDefault(Return(2342));

	std::unique_ptr<BinderObserverConfig> config = createConfig(mEnv);

	// setUpForSharding should have created an enabled config
	EXPECT_TRUE(config->isEnabled());

	// spam: (1234 + 2342 + 21) % 33 = 0
	// calls: the numbers don't matter since callMod is 0

	BinderObserverConfig::TrackingInfo expected = {.trackSpam = true, .trackLatency = false};
	EXPECT_EQ(config->getTrackingInfo(u"IContentProvider", 21), expected);
	}

	} // namespace android