Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f0ff6d2f authored by Mike Yu's avatar Mike Yu
Browse files

Test: Delete kDefaultParams 

Bug: 237766689
Test: atest resolv_integration_test
Change-Id: I94a868340d7a00b7602ad5b95781523628dea814
parent 7df62a92

tests/dns_responder/dns_responder_client_ndk.cpp

+9 −6
Original line number Diff line number Diff line
@@ -35,12 +35,15 @@ using android::net::ResolverStats; 
ResolverParams::Builder::Builder() {

    // Default resolver configuration for opportunistic mode.

    mParcel.netId = TEST_NETID;

    mParcel.sampleValiditySeconds = kDefaultParams[0];

    mParcel.successThreshold = kDefaultParams[1];

    mParcel.minSamples = kDefaultParams[2];

    mParcel.maxSamples = kDefaultParams[3];

    mParcel.baseTimeoutMsec = kDefaultParams[4];

    mParcel.retryCount = kDefaultParams[5];



    // Default Resolver params.

    mParcel.sampleValiditySeconds = 300;

    mParcel.successThreshold = 25;

    mParcel.minSamples = 8;

    mParcel.maxSamples = 8;

    mParcel.baseTimeoutMsec = 1000;

    mParcel.retryCount = 2;



    mParcel.servers = {kDefaultServer};

    mParcel.domains = {kDefaultSearchDomain};

    mParcel.tlsServers = {kDefaultServer};

tests/dns_responder/dns_responder_client_ndk.h

+0 −8
Original line number Diff line number Diff line
@@ -37,14 +37,6 @@ using aidl::android::net::NativeVpnType; 


inline constexpr char kDefaultServer[] = "127.0.0.3";

inline constexpr char kDefaultSearchDomain[] = "example.com";

inline const std::array<int, aidl::android::net::IDnsResolver::RESOLVER_PARAMS_COUNT>

        kDefaultParams = {

                300,      // sample validity in seconds

                25,       // success threshod in percent

                8,    8,  // {MIN,MAX}_SAMPLES

                1000,     // BASE_TIMEOUT_MSEC

                2,        // retry count

};



#define SKIP_IF_REMOTE_VERSION_LESS_THAN(service, version)                                         \

    do {                                                                                           \

tests/resolv_integration_test.cpp

+19 −28
Original line number Diff line number Diff line
@@ -659,12 +659,12 @@ TEST_F(ResolverTest, GetHostByName_Binder) { 
    ASSERT_EQ(1U, mappings.size());

    const DnsResponderClient::Mapping& mapping = mappings[0];



    ASSERT_TRUE(mDnsClient.SetResolversFromParcel(ResolverParams::Builder()

    const auto resolverParams = ResolverParams::Builder()

                                        .setDomains(domains)

                                        .setDnsServers(servers)

                                        .setDotServers({})

                                                          .setParams(kDefaultParams)

                                                          .build()));

                                        .build();

    ASSERT_TRUE(mDnsClient.SetResolversFromParcel(resolverParams));



    const hostent* result = gethostbyname(mapping.host.c_str());

    const size_t total_queries =
@@ -691,15 +691,12 @@ TEST_F(ResolverTest, GetHostByName_Binder) { 
    EXPECT_EQ(servers.size(), res_servers.size());

    EXPECT_EQ(domains.size(), res_domains.size());

    EXPECT_EQ(0U, res_tls_servers.size());

    ASSERT_EQ(static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT), kDefaultParams.size());

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY],

              res_params.sample_validity);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD],

              res_params.success_threshold);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],

              res_params.base_timeout_msec);

    EXPECT_EQ(resolverParams.sampleValiditySeconds, res_params.sample_validity);

    EXPECT_EQ(resolverParams.successThreshold, res_params.success_threshold);

    EXPECT_EQ(resolverParams.minSamples, res_params.min_samples);

    EXPECT_EQ(resolverParams.maxSamples, res_params.max_samples);

    EXPECT_EQ(resolverParams.baseTimeoutMsec, res_params.base_timeout_msec);

    EXPECT_EQ(resolverParams.retryCount, res_params.retry_count);

    EXPECT_EQ(servers.size(), res_stats.size());



    EXPECT_THAT(res_servers, testing::UnorderedElementsAreArray(servers));
@@ -1516,9 +1513,7 @@ TEST_F(ResolverTest, GetAddrInfoFromCustTable_Modify) { 
}



TEST_F(ResolverTest, EmptySetup) {

    std::vector<std::string> servers;

    std::vector<std::string> domains;

    ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));

    ASSERT_TRUE(mDnsClient.SetResolversFromParcel(ResolverParamsParcel{.netId = TEST_NETID}));

    std::vector<std::string> res_servers;

    std::vector<std::string> res_domains;

    std::vector<std::string> res_tls_servers;
@@ -1531,16 +1526,12 @@ TEST_F(ResolverTest, EmptySetup) { 
    EXPECT_EQ(0U, res_servers.size());

    EXPECT_EQ(0U, res_domains.size());

    EXPECT_EQ(0U, res_tls_servers.size());

    ASSERT_EQ(static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT), kDefaultParams.size());

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY],

              res_params.sample_validity);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD],

              res_params.success_threshold);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES], res_params.min_samples);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES], res_params.max_samples);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],

              res_params.base_timeout_msec);

    EXPECT_EQ(kDefaultParams[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT], res_params.retry_count);

    EXPECT_EQ(0U, res_params.sample_validity);

    EXPECT_EQ(0U, res_params.success_threshold);

    EXPECT_EQ(0U, res_params.min_samples);

    EXPECT_EQ(0U, res_params.max_samples);

    // We don't check baseTimeoutMsec and retryCount because their value differ depending on

    // the experiment flags.

}



TEST_F(ResolverTest, SearchPathChange) {