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

Commit 9c622115 authored by Mike Yu's avatar Mike Yu Committed by Automerger Merge Worker
Browse files

Test: Rewrite ResolverTest.KeepListeningUDP am: 1e4e64d9 am: eb4c9964 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/DnsResolver/+/2466320



Change-Id: I3dd953f8b375403994c6d98162539a8f9350ae29
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 41a0fc4f eb4c9964

tests/resolv_integration_test.cpp

+43 −28
Original line number Diff line number Diff line
@@ -6097,6 +6097,12 @@ TEST_P(ResolverParameterizedTest, TruncatedResponse) { 
    EXPECT_EQ(1U, GetNumQueriesForProtocol(dns, IPPROTO_TCP, kHelloExampleCom));

}



// Tests that the DnsResolver can keep listening to the DNS response from previous DNS servers.

// Test scenarios (The timeout for each server is 1 second):

//   1. (During the first iteration of DNS servers) While waiting for the DNS response from the

//      second server, the DnsResolver receives the DNS response from the first server.

//   2. (During the second iteration of DNS servers) While waiting for the DNS response from the

//      second server, the DnsResolver receives the DNS response from the first server.

TEST_F(ResolverTest, KeepListeningUDP) {

    constexpr char listen_addr1[] = "127.0.0.4";

    constexpr char listen_addr2[] = "127.0.0.5";
@@ -6104,42 +6110,51 @@ TEST_F(ResolverTest, KeepListeningUDP) { 
    const std::vector<DnsRecord> records = {

            {host_name, ns_type::ns_t_aaaa, "::1.2.3.4"},

    };

    const std::array<int, IDnsResolver::RESOLVER_PARAMS_COUNT> params = {

            300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */, 1 /* retry count */};

    const int delayTimeMs = 1500;

    auto builder =

            ResolverParams::Builder().setDnsServers({listen_addr1, listen_addr2}).setDotServers({});



    test::DNSResponder neverRespondDns(listen_addr2, "53", static_cast<ns_rcode>(-1));

    neverRespondDns.setResponseProbability(0.0);

    StartDns(neverRespondDns, records);

    test::DNSResponder delayedDns(listen_addr1);

    StartDns(delayedDns, records);



    const struct TestConfig {

        int retryCount;

        int delayTimeMs;

    } testConfigs[]{

            {1, 1500},

            {2, 3500},

    };

    for (const std::string_view callType : {"getaddrinfo", "resnsend"}) {

        for (const auto& cfg : testConfigs) {

            SCOPED_TRACE(fmt::format("callType={}, retryCount={}, delayTimeMs={}", callType,

                                     cfg.retryCount, cfg.delayTimeMs));

            const std::array<int, IDnsResolver::RESOLVER_PARAMS_COUNT> params = {

                    300, 25, 8, 8, 1000 /* BASE_TIMEOUT_MSEC */, cfg.retryCount /* retry count */};



            ScopedSystemProperties sp(kKeepListeningUdpFlag, "1");

    // Re-setup test network to make experiment flag take effect.

            resetNetwork();

            ASSERT_TRUE(mDnsClient.SetResolversFromParcel(builder.setParams(params).build()));



    ASSERT_TRUE(

            mDnsClient.SetResolversFromParcel(ResolverParams::Builder()

                                                      .setDnsServers({listen_addr1, listen_addr2})

                                                      .setDotServers({})

                                                      .setParams(params)

                                                      .build()));

    // There are 2 DNS servers for this test.

    // |delayedDns| will be blocked for |delayTimeMs|, then start to respond to requests.

    // |neverRespondDns| will never respond.

    // In the first try, resolver will send query to |delayedDns| but get timeout error

    // because |delayTimeMs| > DNS timeout.

    // Then it's the second try, resolver will send query to |neverRespondDns| and

    // listen on both servers. Resolver will receive the answer coming from |delayedDns|.



    test::DNSResponder delayedDns(listen_addr1);

    delayedDns.setResponseDelayMs(delayTimeMs);

    StartDns(delayedDns, records);

            delayedDns.setDeferredResp(true);

            std::thread thread([&]() {

                std::this_thread::sleep_for(std::chrono::milliseconds(cfg.delayTimeMs));

                delayedDns.setDeferredResp(false);

            });



    // Specify hints to ensure resolver doing query only 1 round.

            if (callType == "getaddrinfo") {

                const addrinfo hints = {.ai_family = AF_INET6, .ai_socktype = SOCK_DGRAM};

                ScopedAddrinfo result = safe_getaddrinfo(host_name, nullptr, &hints);

    EXPECT_TRUE(result != nullptr);



    std::string result_str = ToString(result);

    EXPECT_TRUE(result_str == "::1.2.3.4") << ", result_str='" << result_str << "'";

                EXPECT_EQ("::1.2.3.4", ToString(result));

            } else {

                int fd = resNetworkQuery(TEST_NETID, host_name, ns_c_in, ns_t_aaaa, 0);

                expectAnswersValid(fd, AF_INET6, "::1.2.3.4");

            }

            // TODO(b/271405311): check that the DNS stats from getResolverInfo() is correct.

            thread.join();

        }

    }

}



TEST_F(ResolverTest, GetAddrInfoParallelLookupTimeout) {