Merge "[AWARE] Test "instant failure" on Aware data-path requests"
diff --git a/tests/cts/hostside/OWNERS b/tests/cts/hostside/OWNERS
new file mode 100644
index 0000000..52c8053
--- /dev/null
+++ b/tests/cts/hostside/OWNERS
@@ -0,0 +1,4 @@
+# Bug component: 61373
+sudheersai@google.com
+lorenzo@google.com
+jchalard@google.com
diff --git a/tests/cts/hostside/app/Android.mk b/tests/cts/hostside/app/Android.mk
index 62e0172..11f6bb1 100644
--- a/tests/cts/hostside/app/Android.mk
+++ b/tests/cts/hostside/app/Android.mk
@@ -21,7 +21,7 @@
LOCAL_MODULE_TAGS := tests
#LOCAL_SDK_VERSION := current
LOCAL_PRIVATE_PLATFORM_APIS := true
-LOCAL_STATIC_JAVA_LIBRARIES := compatibility-device-util ctstestrunner ub-uiautomator \
+LOCAL_STATIC_JAVA_LIBRARIES := compatibility-device-util-axt ctstestrunner-axt ub-uiautomator \
CtsHostsideNetworkTestsAidl
LOCAL_JAVA_LIBRARIES := android.test.runner.stubs android.test.base.stubs
diff --git a/tests/cts/hostside/app/AndroidManifest.xml b/tests/cts/hostside/app/AndroidManifest.xml
index b91f39d..f54b5c1 100644
--- a/tests/cts/hostside/app/AndroidManifest.xml
+++ b/tests/cts/hostside/app/AndroidManifest.xml
@@ -47,7 +47,7 @@
</application>
<instrumentation
- android:name="android.support.test.runner.AndroidJUnitRunner"
+ android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="com.android.cts.net.hostside" />
</manifest>
diff --git a/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java b/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java
index 7c9ce8f..a2443b3 100644
--- a/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java
+++ b/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java
@@ -128,7 +128,7 @@
protected void runDeviceTests(String packageName, String testClassName, String methodName)
throws DeviceNotAvailableException {
RemoteAndroidTestRunner testRunner = new RemoteAndroidTestRunner(packageName,
- "android.support.test.runner.AndroidJUnitRunner", getDevice().getIDevice());
+ "androidx.test.runner.AndroidJUnitRunner", getDevice().getIDevice());
if (testClassName != null) {
if (methodName != null) {
diff --git a/tests/cts/net/Android.mk b/tests/cts/net/Android.mk
index bb1f4c7..2084dbc 100644
--- a/tests/cts/net/Android.mk
+++ b/tests/cts/net/Android.mk
@@ -40,8 +40,8 @@
LOCAL_STATIC_JAVA_LIBRARIES := \
core-tests-support \
- compatibility-device-util \
- ctstestrunner \
+ compatibility-device-util-axt \
+ ctstestrunner-axt \
ctstestserver \
mockwebserver \
junit \
diff --git a/tests/cts/net/AndroidManifest.xml b/tests/cts/net/AndroidManifest.xml
index 2a57c10..630de7e 100644
--- a/tests/cts/net/AndroidManifest.xml
+++ b/tests/cts/net/AndroidManifest.xml
@@ -43,7 +43,7 @@
</receiver>
</application>
- <instrumentation android:name="android.support.test.runner.AndroidJUnitRunner"
+ <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.net.cts"
android:label="CTS tests of android.net">
<meta-data android:name="listener"
diff --git a/tests/cts/net/OWNERS b/tests/cts/net/OWNERS
index dc82bb0..d558556 100644
--- a/tests/cts/net/OWNERS
+++ b/tests/cts/net/OWNERS
@@ -1,2 +1,3 @@
+# Bug component: 31808
lorenzo@google.com
-satk@google.com
\ No newline at end of file
+satk@google.com
diff --git a/tests/cts/net/jni/Android.mk b/tests/cts/net/jni/Android.mk
index 727a44d..ccb1278 100644
--- a/tests/cts/net/jni/Android.mk
+++ b/tests/cts/net/jni/Android.mk
@@ -36,7 +36,7 @@
LOCAL_MODULE := libnativemultinetwork_jni
# Don't include this package in any configuration by default.
LOCAL_MODULE_TAGS := optional
-LOCAL_SRC_FILES := NativeMultinetworkJni.c
+LOCAL_SRC_FILES := NativeMultinetworkJni.cpp
LOCAL_CFLAGS := -Wall -Werror -Wno-format
LOCAL_C_INCLUDES := $(JNI_H_INCLUDE)
LOCAL_SHARED_LIBRARIES := libandroid libnativehelper_compat_libc++ liblog
diff --git a/tests/cts/net/jni/NativeMultinetworkJni.c b/tests/cts/net/jni/NativeMultinetworkJni.c
deleted file mode 100644
index 2fa5291..0000000
--- a/tests/cts/net/jni/NativeMultinetworkJni.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright (C) 2010 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.
- */
-
-
-#define LOG_TAG "MultinetworkApiTest"
-#include <utils/Log.h>
-
-#include <arpa/inet.h>
-#include <errno.h>
-#include <inttypes.h>
-#include <jni.h>
-#include <netdb.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <android/multinetwork.h>
-
-#define UNUSED(X) ((void) (X))
-
-static const char kHostname[] = "connectivitycheck.android.com";
-
-
-JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runGetaddrinfoCheck(
- JNIEnv* env, jclass class, jlong nethandle) {
- UNUSED(env);
- UNUSED(class);
- net_handle_t handle = (net_handle_t) nethandle;
- struct addrinfo *res = NULL;
-
- errno = 0;
- int rval = android_getaddrinfofornetwork(handle, kHostname, NULL, NULL, &res);
- const int saved_errno = errno;
- freeaddrinfo(res);
-
- ALOGD("android_getaddrinfofornetwork(%" PRIu64 ", %s) returned rval=%d errno=%d",
- handle, kHostname, rval, saved_errno);
- return rval == 0 ? 0 : -saved_errno;
-}
-
-JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetprocnetwork(
- JNIEnv* env, jclass class, jlong nethandle) {
- UNUSED(env);
- UNUSED(class);
- net_handle_t handle = (net_handle_t) nethandle;
-
- errno = 0;
- int rval = android_setprocnetwork(handle);
- const int saved_errno = errno;
- ALOGD("android_setprocnetwork(%" PRIu64 ") returned rval=%d errno=%d",
- handle, rval, saved_errno);
- return rval == 0 ? 0 : -saved_errno;
-}
-
-JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetsocknetwork(
- JNIEnv* env, jclass class, jlong nethandle) {
- UNUSED(env);
- UNUSED(class);
- net_handle_t handle = (net_handle_t) nethandle;
-
- errno = 0;
- int fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
- if (fd < 0) {
- ALOGD("socket() failed, errno=%d", errno);
- return -errno;
- }
-
- errno = 0;
- int rval = android_setsocknetwork(handle, fd);
- const int saved_errno = errno;
- ALOGD("android_setprocnetwork(%" PRIu64 ", %d) returned rval=%d errno=%d",
- handle, fd, rval, saved_errno);
- close(fd);
- return rval == 0 ? 0 : -saved_errno;
-}
-
-// Use sizeof("x") - 1 because we need a compile-time constant, and strlen("x")
-// isn't guaranteed to fold to a constant.
-static const int kSockaddrStrLen = INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
-
-void sockaddr_ntop(const struct sockaddr *sa, socklen_t salen, char *dst, const size_t size) {
- char addrstr[INET6_ADDRSTRLEN];
- char portstr[sizeof("65535")];
- char buf[kSockaddrStrLen+1];
-
- int ret = getnameinfo(sa, salen,
- addrstr, sizeof(addrstr),
- portstr, sizeof(portstr),
- NI_NUMERICHOST | NI_NUMERICSERV);
- if (ret == 0) {
- snprintf(buf, sizeof(buf),
- (sa->sa_family == AF_INET6) ? "[%s]:%s" : "%s:%s",
- addrstr, portstr);
- } else {
- sprintf(buf, "???");
- }
-
- strlcpy(dst, buf, size);
-}
-
-JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runDatagramCheck(
- JNIEnv* env, jclass class, jlong nethandle) {
- UNUSED(env);
- UNUSED(class);
- const struct addrinfo kHints = {
- .ai_flags = AI_ADDRCONFIG,
- .ai_family = AF_UNSPEC,
- .ai_socktype = SOCK_DGRAM,
- .ai_protocol = IPPROTO_UDP,
- };
- struct addrinfo *res = NULL;
- net_handle_t handle = (net_handle_t) nethandle;
-
- static const char kPort[] = "443";
- int rval = android_getaddrinfofornetwork(handle, kHostname, kPort, &kHints, &res);
- if (rval != 0) {
- ALOGD("android_getaddrinfofornetwork(%llu, %s) returned rval=%d errno=%d",
- handle, kHostname, rval, errno);
- freeaddrinfo(res);
- return -errno;
- }
-
- // Rely upon getaddrinfo sorting the best destination to the front.
- int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
- if (fd < 0) {
- ALOGD("socket(%d, %d, %d) failed, errno=%d",
- res->ai_family, res->ai_socktype, res->ai_protocol, errno);
- freeaddrinfo(res);
- return -errno;
- }
-
- rval = android_setsocknetwork(handle, fd);
- ALOGD("android_setprocnetwork(%llu, %d) returned rval=%d errno=%d",
- handle, fd, rval, errno);
- if (rval != 0) {
- close(fd);
- freeaddrinfo(res);
- return -errno;
- }
-
- char addrstr[kSockaddrStrLen+1];
- sockaddr_ntop(res->ai_addr, res->ai_addrlen, addrstr, sizeof(addrstr));
- ALOGD("Attempting connect() to %s ...", addrstr);
-
- rval = connect(fd, res->ai_addr, res->ai_addrlen);
- if (rval != 0) {
- close(fd);
- freeaddrinfo(res);
- return -errno;
- }
- freeaddrinfo(res);
-
- struct sockaddr_storage src_addr;
- socklen_t src_addrlen = sizeof(src_addr);
- if (getsockname(fd, (struct sockaddr *)&src_addr, &src_addrlen) != 0) {
- close(fd);
- return -errno;
- }
- sockaddr_ntop((const struct sockaddr *)&src_addr, sizeof(src_addr), addrstr, sizeof(addrstr));
- ALOGD("... from %s", addrstr);
-
- // Don't let reads or writes block indefinitely.
- const struct timeval timeo = { 2, 0 }; // 2 seconds
- setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
- setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
-
- // For reference see:
- // https://tools.ietf.org/html/draft-tsvwg-quic-protocol-01#section-6.1
- uint8_t quic_packet[] = {
- 0x0c, // public flags: 64bit conn ID, 8bit sequence number
- 0, 0, 0, 0, 0, 0, 0, 0, // 64bit connection ID
- 0x01, // sequence number
- 0x00, // private flags
- 0x07, // type: regular frame type "PING"
- };
-
- arc4random_buf(quic_packet + 1, 8); // random connection ID
-
- uint8_t response[1500];
- ssize_t sent, rcvd;
- static const int MAX_RETRIES = 5;
- int i, errnum = 0;
-
- for (i = 0; i < MAX_RETRIES; i++) {
- sent = send(fd, quic_packet, sizeof(quic_packet), 0);
- if (sent < (ssize_t)sizeof(quic_packet)) {
- errnum = errno;
- ALOGD("send(QUIC packet) returned sent=%zd, errno=%d", sent, errnum);
- close(fd);
- return -errnum;
- }
-
- rcvd = recv(fd, response, sizeof(response), 0);
- if (rcvd > 0) {
- break;
- } else {
- errnum = errno;
- ALOGD("[%d/%d] recv(QUIC response) returned rcvd=%zd, errno=%d",
- i + 1, MAX_RETRIES, rcvd, errnum);
- }
- }
- if (rcvd < sent) {
- ALOGD("QUIC UDP %s: sent=%zd but rcvd=%zd, errno=%d", kPort, sent, rcvd, errnum);
- if (rcvd <= 0) {
- ALOGD("Does this network block UDP port %s?", kPort);
- }
- close(fd);
- return -EPROTO;
- }
-
- int conn_id_cmp = memcmp(quic_packet + 1, response + 1, 8);
- if (conn_id_cmp != 0) {
- ALOGD("sent and received connection IDs do not match");
- close(fd);
- return -EPROTO;
- }
-
- // TODO: log, and compare to the IP address encoded in the
- // response, since this should be a public reset packet.
-
- close(fd);
- return 0;
-}
diff --git a/tests/cts/net/jni/NativeMultinetworkJni.cpp b/tests/cts/net/jni/NativeMultinetworkJni.cpp
new file mode 100644
index 0000000..332148b
--- /dev/null
+++ b/tests/cts/net/jni/NativeMultinetworkJni.cpp
@@ -0,0 +1,510 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+
+#define LOG_TAG "MultinetworkApiTest"
+#include <utils/Log.h>
+
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <jni.h>
+#include <netdb.h>
+#include <poll.h> /* poll */
+#include <resolv.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+
+#include <string>
+
+#include <android/multinetwork.h>
+#include <nativehelper/JNIHelp.h>
+
+#define EXPECT_GE(env, actual, expected, msg) \
+ do { \
+ if (actual < expected) { \
+ jniThrowExceptionFmt(env, "java/lang/AssertionError", \
+ "%s:%d: %s EXPECT_GE: expected %d, got %d", \
+ __FILE__, __LINE__, expected, actual); \
+ } \
+ } while (0)
+
+#define EXPECT_GT(env, actual, expected, msg) \
+ do { \
+ if (actual <= expected) { \
+ jniThrowExceptionFmt(env, "java/lang/AssertionError", \
+ "%s:%d: %s EXPECT_GT: expected %d, got %d", \
+ __FILE__, __LINE__, msg, expected, actual); \
+ } \
+ } while (0)
+
+#define EXPECT_EQ(env, expected, actual, msg) \
+ do { \
+ if (actual != expected) { \
+ jniThrowExceptionFmt(env, "java/lang/AssertionError", \
+ "%s:%d: %s EXPECT_EQ: expected %d, got %d", \
+ __FILE__, __LINE__, msg, expected, actual); \
+ } \
+ } while (0)
+
+static const int MAXPACKET = 8 * 1024;
+static const int TIMEOUT_MS = 2000;
+static const char kHostname[] = "connectivitycheck.android.com";
+static const char kNxDomainName[] = "test1-nx.metric.gstatic.com";
+static const char kGoogleName[] = "www.google.com";
+
+int makeQuery(const char* name, int qtype, uint8_t* buf, size_t buflen) {
+ return res_mkquery(ns_o_query, name, ns_c_in, qtype, NULL, 0, NULL, buf, buflen);
+}
+
+int getAsyncResponse(JNIEnv* env, int fd, int timeoutMs, int* rcode, uint8_t* buf, size_t bufLen) {
+ struct pollfd wait_fd = { .fd = fd, .events = POLLIN };
+
+ poll(&wait_fd, 1, timeoutMs);
+ if (wait_fd.revents & POLLIN) {
+ int n = android_res_nresult(fd, rcode, buf, bufLen);
+ // Verify that android_res_nresult() closed the fd
+ char dummy;
+ EXPECT_EQ(env, -1, read(fd, &dummy, sizeof dummy), "res_nresult check for closing fd");
+ EXPECT_EQ(env, EBADF, errno, "res_nresult check for errno");
+ return n;
+ }
+
+ return -EREMOTEIO;
+}
+
+int extractIpAddressAnswers(uint8_t* buf, size_t bufLen, int family) {
+ ns_msg handle;
+ if (ns_initparse((const uint8_t*) buf, bufLen, &handle) < 0) {
+ return -EREMOTEIO;
+ }
+ const int ancount = ns_msg_count(handle, ns_s_an);
+ ns_rr rr;
+ for (int i = 0; i < ancount; i++) {
+ if (ns_parserr(&handle, ns_s_an, i, &rr) < 0) {
+ continue;
+ }
+ const uint8_t* rdata = ns_rr_rdata(rr);
+ char buffer[INET6_ADDRSTRLEN];
+ if (inet_ntop(family, (const char*) rdata, buffer, sizeof(buffer)) == NULL) {
+ return -errno;
+ }
+ }
+ return 0;
+}
+
+int expectAnswersValid(JNIEnv* env, int fd, int family, int expectedRcode) {
+ int rcode = -1;
+ uint8_t buf[MAXPACKET] = {};
+ int res = getAsyncResponse(env, fd, TIMEOUT_MS, &rcode, buf, MAXPACKET);
+ if (res < 0) {
+ return res;
+ }
+ if(rcode != expectedRcode) {
+ ALOGD("rcode:%d, expectedRcode = %d", rcode, expectedRcode);
+ return -EREMOTEIO;
+ }
+
+ if (expectedRcode == ns_r_noerror && res > 0) {
+ return extractIpAddressAnswers(buf, res, family);
+ }
+ return 0;
+}
+
+int expectAnswersNotValid(JNIEnv* env, int fd, int expectedErrno) {
+ int rcode = -1;
+ uint8_t buf[MAXPACKET] = {};
+ int res = getAsyncResponse(env, fd, TIMEOUT_MS, &rcode, buf, MAXPACKET);
+ if (res != expectedErrno) {
+ ALOGD("res:%d, expectedErrno = %d", res, expectedErrno);
+ return (res > 0) ? -EREMOTEIO : res;
+ }
+ return 0;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNqueryCheck(
+ JNIEnv* env, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+
+ // V4
+ int fd = android_res_nquery(handle, kHostname, ns_c_in, ns_t_a, 0);
+ EXPECT_GE(env, fd, 0, "v4 res_nquery");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror),
+ "v4 res_nquery check answers");
+
+ // V4 NXDOMAIN
+ fd = android_res_nquery(handle, kNxDomainName, ns_c_in, ns_t_a,
+ ANDROID_RESOLV_NO_CACHE_LOOKUP);
+ EXPECT_GE(env, fd, 0, "v4 res_nquery NXDOMAIN");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_nxdomain),
+ "v4 res_nquery NXDOMAIN check answers");
+
+ // V6
+ fd = android_res_nquery(handle, kHostname, ns_c_in, ns_t_aaaa, 0);
+ EXPECT_GE(env, fd, 0, "v6 res_nquery");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror),
+ "v6 res_nquery check answers");
+
+ // V6 NXDOMAIN
+ fd = android_res_nquery(handle, kNxDomainName, ns_c_in, ns_t_aaaa,
+ ANDROID_RESOLV_NO_CACHE_LOOKUP);
+ EXPECT_GE(env, fd, 0, "v6 res_nquery NXDOMAIN");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_nxdomain),
+ "v6 res_nquery NXDOMAIN check answers");
+
+ return 0;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNsendCheck(
+ JNIEnv* env, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+ // V4
+ uint8_t buf1[MAXPACKET] = {};
+
+ int len1 = makeQuery(kGoogleName, ns_t_a, buf1, sizeof(buf1));
+ EXPECT_GT(env, len1, 0, "v4 res_mkquery 1st");
+
+ uint8_t buf2[MAXPACKET] = {};
+ int len2 = makeQuery(kHostname, ns_t_a, buf2, sizeof(buf2));
+ EXPECT_GT(env, len2, 0, "v4 res_mkquery 2nd");
+
+ int fd1 = android_res_nsend(handle, buf1, len1, 0);
+ EXPECT_GE(env, fd1, 0, "v4 res_nsend 1st");
+ int fd2 = android_res_nsend(handle, buf2, len2, 0);
+ EXPECT_GE(env, fd2, 0, "v4 res_nsend 2nd");
+
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd2, AF_INET, ns_r_noerror),
+ "v4 res_nsend 2nd check answers");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET, ns_r_noerror),
+ "v4 res_nsend 1st check answers");
+
+ // V4 NXDOMAIN
+ memset(buf1, 0, sizeof(buf1));
+ len1 = makeQuery(kNxDomainName, ns_t_a, buf1, sizeof(buf1));
+ EXPECT_GT(env, len1, 0, "v4 res_mkquery NXDOMAIN");
+ fd1 = android_res_nsend(handle, buf1, len1, ANDROID_RESOLV_NO_CACHE_LOOKUP);
+ EXPECT_GE(env, fd1, 0, "v4 res_nsend NXDOMAIN");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET, ns_r_nxdomain),
+ "v4 res_nsend NXDOMAIN check answers");
+
+ // V6
+ memset(buf1, 0, sizeof(buf1));
+ memset(buf2, 0, sizeof(buf2));
+ len1 = makeQuery(kGoogleName, ns_t_aaaa, buf1, sizeof(buf1));
+ EXPECT_GT(env, len1, 0, "v6 res_mkquery 1st");
+ len2 = makeQuery(kHostname, ns_t_aaaa, buf2, sizeof(buf2));
+ EXPECT_GT(env, len2, 0, "v6 res_mkquery 2nd");
+
+ fd1 = android_res_nsend(handle, buf1, len1, 0);
+ EXPECT_GE(env, fd1, 0, "v6 res_nsend 1st");
+ fd2 = android_res_nsend(handle, buf2, len2, 0);
+ EXPECT_GE(env, fd2, 0, "v6 res_nsend 2nd");
+
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd2, AF_INET6, ns_r_noerror),
+ "v6 res_nsend 2nd check answers");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET6, ns_r_noerror),
+ "v6 res_nsend 1st check answers");
+
+ // // V6 NXDOMAIN
+ memset(buf1, 0, sizeof(buf1));
+ len1 = makeQuery(kNxDomainName, ns_t_aaaa, buf1, sizeof(buf1));
+ EXPECT_GT(env, len1, 0, "v6 res_mkquery NXDOMAIN");
+ fd1 = android_res_nsend(handle, buf1, len1, ANDROID_RESOLV_NO_CACHE_LOOKUP);
+ EXPECT_GE(env, fd1, 0, "v6 res_nsend NXDOMAIN");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd1, AF_INET6, ns_r_nxdomain),
+ "v6 res_nsend NXDOMAIN check answers");
+
+ return 0;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNcancelCheck(
+ JNIEnv* env, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+
+ int fd = android_res_nquery(handle, kGoogleName, ns_c_in, ns_t_a, 0);
+ int rcode = -1;
+ uint8_t buf[MAXPACKET] = {};
+ android_res_cancel(fd);
+ android_res_cancel(fd);
+
+ EXPECT_EQ(env, -EBADF, android_res_nresult(fd, &rcode, buf, MAXPACKET), "res_cancel");
+ return 0;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runResNapiMalformedCheck(
+ JNIEnv* env, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+
+ // It is the equivalent of "dig . a", Query with an empty name.
+ int fd = android_res_nquery(handle, "", ns_c_in, ns_t_a, 0);
+ EXPECT_GE(env, fd, 0, "res_nquery root");
+ EXPECT_EQ(env, 0, expectAnswersValid(env, fd, AF_INET, ns_r_noerror),
+ "res_nquery root check answers");
+
+ // Label limit 63
+ std::string exceedingLabelQuery = "www." + std::string(70, 'g') + ".com";
+ // Name limit 255
+ std::string exceedingDomainQuery = "www." + std::string(255, 'g') + ".com";
+
+ fd = android_res_nquery(handle, exceedingLabelQuery.c_str(), ns_c_in, ns_t_a, 0);
+ EXPECT_EQ(env, -EMSGSIZE, fd, "res_nquery exceedingLabelQuery");
+ fd = android_res_nquery(handle, exceedingDomainQuery.c_str(), ns_c_in, ns_t_a, 0);
+ EXPECT_EQ(env, -EMSGSIZE, fd, "res_nquery exceedingDomainQuery");
+
+ uint8_t buf[10] = {};
+ // empty BLOB
+ fd = android_res_nsend(handle, buf, 10, 0);
+ EXPECT_GE(env, fd, 0, "res_nsend empty BLOB");
+ EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL),
+ "res_nsend empty BLOB check answers");
+
+ uint8_t largeBuf[2 * MAXPACKET] = {};
+ // A buffer larger than 8KB
+ fd = android_res_nsend(handle, largeBuf, sizeof(largeBuf), 0);
+ EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend buffer larger than 8KB");
+
+ // 1000 bytes filled with 0. This returns EMSGSIZE because FrameworkListener limits the size of
+ // commands to 1024 bytes. TODO: b/126307309
+ fd = android_res_nsend(handle, largeBuf, 1000, 0);
+ EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend 1000 bytes filled with 0");
+
+ // 500 bytes filled with 0
+ fd = android_res_nsend(handle, largeBuf, 500, 0);
+ EXPECT_GE(env, fd, 0, "res_nsend 500 bytes filled with 0");
+ EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL),
+ "res_nsend 500 bytes filled with 0 check answers");
+
+ // 1000 bytes filled with 0xFF
+ uint8_t ffBuf[1001] = {};
+ memset(ffBuf, 0xFF, sizeof(ffBuf));
+ ffBuf[1000] = '\0';
+ fd = android_res_nsend(handle, ffBuf, sizeof(ffBuf), 0);
+ EXPECT_EQ(env, -EMSGSIZE, fd, "res_nsend 1000 bytes filled with 0xFF");
+
+ // 500 bytes filled with 0xFF
+ ffBuf[501] = '\0';
+ fd = android_res_nsend(handle, ffBuf, 500, 0);
+ EXPECT_GE(env, fd, 0, "res_nsend 500 bytes filled with 0xFF");
+ EXPECT_EQ(env, 0, expectAnswersNotValid(env, fd, -EINVAL),
+ "res_nsend 500 bytes filled with 0xFF check answers");
+
+ return 0;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runGetaddrinfoCheck(
+ JNIEnv*, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+ struct addrinfo *res = NULL;
+
+ errno = 0;
+ int rval = android_getaddrinfofornetwork(handle, kHostname, NULL, NULL, &res);
+ const int saved_errno = errno;
+ freeaddrinfo(res);
+
+ ALOGD("android_getaddrinfofornetwork(%" PRIu64 ", %s) returned rval=%d errno=%d",
+ handle, kHostname, rval, saved_errno);
+ return rval == 0 ? 0 : -saved_errno;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetprocnetwork(
+ JNIEnv*, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+
+ errno = 0;
+ int rval = android_setprocnetwork(handle);
+ const int saved_errno = errno;
+ ALOGD("android_setprocnetwork(%" PRIu64 ") returned rval=%d errno=%d",
+ handle, rval, saved_errno);
+ return rval == 0 ? 0 : -saved_errno;
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runSetsocknetwork(
+ JNIEnv*, jclass, jlong nethandle) {
+ net_handle_t handle = (net_handle_t) nethandle;
+
+ errno = 0;
+ int fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
+ if (fd < 0) {
+ ALOGD("socket() failed, errno=%d", errno);
+ return -errno;
+ }
+
+ errno = 0;
+ int rval = android_setsocknetwork(handle, fd);
+ const int saved_errno = errno;
+ ALOGD("android_setprocnetwork(%" PRIu64 ", %d) returned rval=%d errno=%d",
+ handle, fd, rval, saved_errno);
+ close(fd);
+ return rval == 0 ? 0 : -saved_errno;
+}
+
+// Use sizeof("x") - 1 because we need a compile-time constant, and strlen("x")
+// isn't guaranteed to fold to a constant.
+static const int kSockaddrStrLen = INET6_ADDRSTRLEN + sizeof("[]:65535") - 1;
+
+void sockaddr_ntop(const struct sockaddr *sa, socklen_t salen, char *dst, const size_t size) {
+ char addrstr[INET6_ADDRSTRLEN];
+ char portstr[sizeof("65535")];
+ char buf[kSockaddrStrLen+1];
+
+ int ret = getnameinfo(sa, salen,
+ addrstr, sizeof(addrstr),
+ portstr, sizeof(portstr),
+ NI_NUMERICHOST | NI_NUMERICSERV);
+ if (ret == 0) {
+ snprintf(buf, sizeof(buf),
+ (sa->sa_family == AF_INET6) ? "[%s]:%s" : "%s:%s",
+ addrstr, portstr);
+ } else {
+ sprintf(buf, "???");
+ }
+
+ strlcpy(dst, buf, size);
+}
+
+extern "C"
+JNIEXPORT jint Java_android_net_cts_MultinetworkApiTest_runDatagramCheck(
+ JNIEnv*, jclass, jlong nethandle) {
+ const struct addrinfo kHints = {
+ .ai_flags = AI_ADDRCONFIG,
+ .ai_family = AF_UNSPEC,
+ .ai_socktype = SOCK_DGRAM,
+ .ai_protocol = IPPROTO_UDP,
+ };
+ struct addrinfo *res = NULL;
+ net_handle_t handle = (net_handle_t) nethandle;
+
+ static const char kPort[] = "443";
+ int rval = android_getaddrinfofornetwork(handle, kHostname, kPort, &kHints, &res);
+ if (rval != 0) {
+ ALOGD("android_getaddrinfofornetwork(%llu, %s) returned rval=%d errno=%d",
+ handle, kHostname, rval, errno);
+ freeaddrinfo(res);
+ return -errno;
+ }
+
+ // Rely upon getaddrinfo sorting the best destination to the front.
+ int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+ if (fd < 0) {
+ ALOGD("socket(%d, %d, %d) failed, errno=%d",
+ res->ai_family, res->ai_socktype, res->ai_protocol, errno);
+ freeaddrinfo(res);
+ return -errno;
+ }
+
+ rval = android_setsocknetwork(handle, fd);
+ ALOGD("android_setprocnetwork(%llu, %d) returned rval=%d errno=%d",
+ handle, fd, rval, errno);
+ if (rval != 0) {
+ close(fd);
+ freeaddrinfo(res);
+ return -errno;
+ }
+
+ char addrstr[kSockaddrStrLen+1];
+ sockaddr_ntop(res->ai_addr, res->ai_addrlen, addrstr, sizeof(addrstr));
+ ALOGD("Attempting connect() to %s ...", addrstr);
+
+ rval = connect(fd, res->ai_addr, res->ai_addrlen);
+ if (rval != 0) {
+ close(fd);
+ freeaddrinfo(res);
+ return -errno;
+ }
+ freeaddrinfo(res);
+
+ struct sockaddr_storage src_addr;
+ socklen_t src_addrlen = sizeof(src_addr);
+ if (getsockname(fd, (struct sockaddr *)&src_addr, &src_addrlen) != 0) {
+ close(fd);
+ return -errno;
+ }
+ sockaddr_ntop((const struct sockaddr *)&src_addr, sizeof(src_addr), addrstr, sizeof(addrstr));
+ ALOGD("... from %s", addrstr);
+
+ // Don't let reads or writes block indefinitely.
+ const struct timeval timeo = { 2, 0 }; // 2 seconds
+ setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
+ setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
+
+ // For reference see:
+ // https://tools.ietf.org/html/draft-tsvwg-quic-protocol-01#section-6.1
+ uint8_t quic_packet[] = {
+ 0x0c, // public flags: 64bit conn ID, 8bit sequence number
+ 0, 0, 0, 0, 0, 0, 0, 0, // 64bit connection ID
+ 0x01, // sequence number
+ 0x00, // private flags
+ 0x07, // type: regular frame type "PING"
+ };
+
+ arc4random_buf(quic_packet + 1, 8); // random connection ID
+
+ uint8_t response[1500];
+ ssize_t sent, rcvd;
+ static const int MAX_RETRIES = 5;
+ int i, errnum = 0;
+
+ for (i = 0; i < MAX_RETRIES; i++) {
+ sent = send(fd, quic_packet, sizeof(quic_packet), 0);
+ if (sent < (ssize_t)sizeof(quic_packet)) {
+ errnum = errno;
+ ALOGD("send(QUIC packet) returned sent=%zd, errno=%d", sent, errnum);
+ close(fd);
+ return -errnum;
+ }
+
+ rcvd = recv(fd, response, sizeof(response), 0);
+ if (rcvd > 0) {
+ break;
+ } else {
+ errnum = errno;
+ ALOGD("[%d/%d] recv(QUIC response) returned rcvd=%zd, errno=%d",
+ i + 1, MAX_RETRIES, rcvd, errnum);
+ }
+ }
+ if (rcvd < sent) {
+ ALOGD("QUIC UDP %s: sent=%zd but rcvd=%zd, errno=%d", kPort, sent, rcvd, errnum);
+ if (rcvd <= 0) {
+ ALOGD("Does this network block UDP port %s?", kPort);
+ }
+ close(fd);
+ return -EPROTO;
+ }
+
+ int conn_id_cmp = memcmp(quic_packet + 1, response + 1, 8);
+ if (conn_id_cmp != 0) {
+ ALOGD("sent and received connection IDs do not match");
+ close(fd);
+ return -EPROTO;
+ }
+
+ // TODO: log, and compare to the IP address encoded in the
+ // response, since this should be a public reset packet.
+
+ close(fd);
+ return 0;
+}
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index 01a7951..5077f55 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -24,6 +24,7 @@
import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.provider.Settings.Global.NETWORK_METERED_MULTIPATH_PREFERENCE;
+
import static com.android.compatibility.common.util.SystemUtil.runShellCommand;
import android.app.Instrumentation;
@@ -50,41 +51,39 @@
import android.os.SystemClock;
import android.os.SystemProperties;
import android.provider.Settings;
-import android.support.test.InstrumentationRegistry;
import android.system.Os;
import android.system.OsConstants;
import android.test.AndroidTestCase;
import android.text.TextUtils;
import android.util.Log;
+import androidx.test.InstrumentationRegistry;
+
import com.android.compatibility.common.util.SystemUtil;
import com.android.internal.R;
import com.android.internal.telephony.PhoneConstants;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.InputStream;
+import libcore.io.Streams;
+
import java.io.IOException;
+import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
-import java.lang.NumberFormatException;
import java.net.HttpURLConnection;
import java.net.Inet6Address;
import java.net.InetAddress;
-import java.net.Socket;
import java.net.InetSocketAddress;
+import java.net.Socket;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.HashMap;
-import java.util.Scanner;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import libcore.io.Streams;
public class ConnectivityManagerTest extends AndroidTestCase {
diff --git a/tests/cts/net/src/android/net/cts/MacAddressTest.java b/tests/cts/net/src/android/net/cts/MacAddressTest.java
index ace1cde..af1e760 100644
--- a/tests/cts/net/src/android/net/cts/MacAddressTest.java
+++ b/tests/cts/net/src/android/net/cts/MacAddressTest.java
@@ -19,11 +19,13 @@
import static android.net.MacAddress.TYPE_BROADCAST;
import static android.net.MacAddress.TYPE_MULTICAST;
import static android.net.MacAddress.TYPE_UNICAST;
+
import static org.junit.Assert.fail;
import android.net.MacAddress;
-import android.support.test.filters.SmallTest;
-import android.support.test.runner.AndroidJUnit4;
+
+import androidx.test.filters.SmallTest;
+import androidx.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
diff --git a/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java b/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java
index b2c9d9b..c3e65b7 100644
--- a/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java
+++ b/tests/cts/net/src/android/net/cts/MultinetworkApiTest.java
@@ -43,6 +43,12 @@
private static native int runSetprocnetwork(long networkHandle);
private static native int runSetsocknetwork(long networkHandle);
private static native int runDatagramCheck(long networkHandle);
+ private static native int runResNapiMalformedCheck(long networkHandle);
+ private static native int runResNcancelCheck(long networkHandle);
+ private static native int runResNqueryCheck(long networkHandle);
+ private static native int runResNsendCheck(long networkHandle);
+
+
private ConnectivityManager mCM;
@@ -175,4 +181,14 @@
fail();
} catch (IllegalArgumentException e) {}
}
+
+ public void testResNApi() {
+ for (Network network : getTestableNetworks()) {
+ // Throws AssertionError directly in jni function if test fail.
+ runResNqueryCheck(network.getNetworkHandle());
+ runResNsendCheck(network.getNetworkHandle());
+ runResNcancelCheck(network.getNetworkHandle());
+ runResNapiMalformedCheck(network.getNetworkHandle());
+ }
+ }
}
diff --git a/tests/cts/net/src/android/net/cts/NetworkWatchlistTest.java b/tests/cts/net/src/android/net/cts/NetworkWatchlistTest.java
index e85de2a..e0c03a1 100644
--- a/tests/cts/net/src/android/net/cts/NetworkWatchlistTest.java
+++ b/tests/cts/net/src/android/net/cts/NetworkWatchlistTest.java
@@ -24,9 +24,10 @@
import android.content.Context;
import android.net.ConnectivityManager;
import android.os.FileUtils;
-import android.support.test.filters.SmallTest;
-import android.support.test.runner.AndroidJUnit4;
-import android.support.test.InstrumentationRegistry;
+
+import androidx.test.InstrumentationRegistry;
+import androidx.test.filters.SmallTest;
+import androidx.test.runner.AndroidJUnit4;
import com.android.compatibility.common.util.ApiLevelUtil;
import com.android.compatibility.common.util.SystemUtil;
@@ -37,7 +38,6 @@
import org.junit.Test;
import org.junit.runner.RunWith;
-
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
diff --git a/tests/cts/net/src/android/net/cts/TrafficStatsTest.java b/tests/cts/net/src/android/net/cts/TrafficStatsTest.java
index a8743fa..af096da 100755
--- a/tests/cts/net/src/android/net/cts/TrafficStatsTest.java
+++ b/tests/cts/net/src/android/net/cts/TrafficStatsTest.java
@@ -16,6 +16,7 @@
package android.net.cts;
+import android.net.NetworkStats;
import android.net.TrafficStats;
import android.os.Process;
import android.test.AndroidTestCase;
@@ -99,6 +100,7 @@
final int byteCount = 1024;
final int packetCount = 1024;
+ TrafficStats.startDataProfiling(null);
final ServerSocket server = new ServerSocket(0);
new Thread("TrafficStatsTest.testTrafficStatsForLocalhost") {
@Override
@@ -153,6 +155,7 @@
Thread.sleep(1000);
} catch (InterruptedException e) {
}
+ NetworkStats testStats = TrafficStats.stopDataProfiling(null);
long mobileTxPacketsAfter = TrafficStats.getMobileTxPackets();
long mobileRxPacketsAfter = TrafficStats.getMobileRxPackets();
@@ -194,6 +197,24 @@
Log.i(LOG_TAG, "lingering traffic data: " + deltaTxOtherPackets + "/" + deltaRxOtherPackets);
}
+ // Check the per uid stats read from data profiling have the stats expected. The data
+ // profiling snapshot is generated from readNetworkStatsDetail() method in
+ // networkStatsService and in this way we can verify the detail networkStats of a given uid
+ // is correct.
+ NetworkStats.Entry entry = testStats.getTotal(null, Process.myUid());
+ assertTrue("txPackets detail: " + entry.txPackets + " uidTxPackets: " + uidTxDeltaPackets,
+ entry.txPackets >= packetCount + minExpectedExtraPackets
+ && entry.txPackets <= uidTxDeltaPackets);
+ assertTrue("rxPackets detail: " + entry.rxPackets + " uidRxPackets: " + uidRxDeltaPackets,
+ entry.rxPackets >= packetCount + minExpectedExtraPackets
+ && entry.rxPackets <= uidRxDeltaPackets);
+ assertTrue("txBytes detail: " + entry.txBytes + " uidTxDeltaBytes: " + uidTxDeltaBytes,
+ entry.txBytes >= tcpPacketToIpBytes(packetCount, byteCount)
+ + tcpPacketToIpBytes(minExpectedExtraPackets, 0) && entry.txBytes <= uidTxDeltaBytes);
+ assertTrue("rxBytes detail: " + entry.rxBytes + " uidRxDeltaBytes: " + uidRxDeltaBytes,
+ entry.rxBytes >= tcpPacketToIpBytes(packetCount, byteCount)
+ + tcpPacketToIpBytes(minExpectedExtraPackets, 0) && entry.rxBytes <= uidRxDeltaBytes);
+
assertTrue("uidtxp: " + uidTxPacketsBefore + " -> " + uidTxPacketsAfter + " delta=" + uidTxDeltaPackets +
" Wanted: " + uidTxDeltaPackets + ">=" + packetCount + "+" + minExpectedExtraPackets + " && " +
uidTxDeltaPackets + "<=" + packetCount + "+" + packetCount + "+" + maxExpectedExtraPackets + "+" + deltaTxOtherPackets,
diff --git a/tests/cts/net/src/android/net/cts/UriTest.java b/tests/cts/net/src/android/net/cts/UriTest.java
index 5344f93..40b8fb7 100644
--- a/tests/cts/net/src/android/net/cts/UriTest.java
+++ b/tests/cts/net/src/android/net/cts/UriTest.java
@@ -568,6 +568,15 @@
"ftp://root:love@ftp.android.com:2121/");
}
+ public void testToSafeString_rtsp() {
+ checkToSafeString("rtsp://rtsp.android.com/...", "rtsp://rtsp.android.com/");
+ checkToSafeString("rtsp://rtsp.android.com/...", "rtsp://rtsp.android.com/video.mov");
+ checkToSafeString("rtsp://rtsp.android.com/...", "rtsp://rtsp.android.com/video.mov?param");
+ checkToSafeString("RtsP://rtsp.android.com/...", "RtsP://anonymous@rtsp.android.com/");
+ checkToSafeString("rtsp://rtsp.android.com:2121/...",
+ "rtsp://username:password@rtsp.android.com:2121/");
+ }
+
public void testToSafeString_notSupport() {
checkToSafeString("unsupported://ajkakjah/askdha/secret?secret",
"unsupported://ajkakjah/askdha/secret?secret");
diff --git a/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java b/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java
index 5e91366..c80e372 100644
--- a/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/ConcurrencyTest.java
@@ -16,36 +16,66 @@
package android.net.wifi.cts;
+import static org.junit.Assert.assertNotEquals;
+
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
+import android.content.pm.PackageManager;
import android.net.ConnectivityManager;
import android.net.ConnectivityManager.NetworkCallback;
import android.net.Network;
import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.wifi.WifiManager;
import android.net.wifi.p2p.WifiP2pManager;
-import static android.net.wifi.p2p.WifiP2pManager.WIFI_P2P_STATE_DISABLED;
-import static android.net.wifi.p2p.WifiP2pManager.WIFI_P2P_STATE_ENABLED;
+import android.provider.Settings;
import android.test.AndroidTestCase;
+import android.util.Log;
import com.android.compatibility.common.util.SystemUtil;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.LinkedList;
+import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
public class ConcurrencyTest extends AndroidTestCase {
private class MySync {
- int expectedWifiState;
- int expectedP2pState;
+ static final int WIFI_STATE = 0;
+ static final int P2P_STATE = 1;
+ static final int DISCOVERY_STATE = 2;
+ static final int NETWORK_INFO = 3;
+
+ public BitSet pendingSync = new BitSet();
+
+ public int expectedWifiState;
+ public int expectedP2pState;
+ public int expectedDiscoveryState;
+ public NetworkInfo expectedNetworkInfo;
+ }
+
+ private class MyResponse {
+ public boolean valid = false;
+
+ public boolean success;
+ public int p2pState;
+ public int discoveryState;
+ public NetworkInfo networkInfo;
}
private WifiManager mWifiManager;
+ private WifiP2pManager mWifiP2pManager;
+ private WifiP2pManager.Channel mWifiP2pChannel;
private MySync mMySync = new MySync();
+ private MyResponse mMyResponse = new MyResponse();
- private static final String TAG = "WifiInfoTest";
+ private static final String TAG = "ConcurrencyTest";
private static final int TIMEOUT_MSEC = 6000;
private static final int WAIT_MSEC = 60;
private static final int DURATION = 10000;
@@ -56,16 +86,33 @@
final String action = intent.getAction();
if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
synchronized (mMySync) {
+ mMySync.pendingSync.set(MySync.WIFI_STATE);
mMySync.expectedWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
WifiManager.WIFI_STATE_DISABLED);
mMySync.notify();
}
} else if(action.equals(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION)) {
synchronized (mMySync) {
+ mMySync.pendingSync.set(MySync.P2P_STATE);
mMySync.expectedP2pState = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE,
WifiP2pManager.WIFI_P2P_STATE_DISABLED);
mMySync.notify();
}
+ } else if (action.equals(WifiP2pManager.WIFI_P2P_DISCOVERY_CHANGED_ACTION)) {
+ synchronized (mMySync) {
+ mMySync.pendingSync.set(MySync.DISCOVERY_STATE);
+ mMySync.expectedDiscoveryState = intent.getIntExtra(
+ WifiP2pManager.EXTRA_DISCOVERY_STATE,
+ WifiP2pManager.WIFI_P2P_DISCOVERY_STOPPED);
+ mMySync.notify();
+ }
+ } else if (action.equals(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION)) {
+ synchronized (mMySync) {
+ mMySync.pendingSync.set(MySync.NETWORK_INFO);
+ mMySync.expectedNetworkInfo = (NetworkInfo) intent.getExtra(
+ WifiP2pManager.EXTRA_NETWORK_INFO, null);
+ mMySync.notify();
+ }
}
}
};
@@ -81,6 +128,8 @@
mIntentFilter = new IntentFilter();
mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_DISCOVERY_CHANGED_ACTION);
+ mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
mContext.registerReceiver(mReceiver, mIntentFilter);
mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
@@ -92,6 +141,8 @@
assertTrue(!mWifiManager.isWifiEnabled());
mMySync.expectedWifiState = WifiManager.WIFI_STATE_DISABLED;
mMySync.expectedP2pState = WifiP2pManager.WIFI_P2P_STATE_DISABLED;
+ mMySync.expectedDiscoveryState = WifiP2pManager.WIFI_P2P_DISCOVERY_STOPPED;
+ mMySync.expectedNetworkInfo = null;
}
@Override
@@ -108,16 +159,66 @@
super.tearDown();
}
- private void waitForBroadcasts() {
+ private boolean waitForBroadcasts(List<Integer> waitSyncList) {
synchronized (mMySync) {
long timeout = System.currentTimeMillis() + TIMEOUT_MSEC;
- while (System.currentTimeMillis() < timeout
- && (mMySync.expectedWifiState != WifiManager.WIFI_STATE_ENABLED ||
- mMySync.expectedP2pState != WifiP2pManager.WIFI_P2P_STATE_ENABLED)) {
+ while (System.currentTimeMillis() < timeout) {
+ List<Integer> handledSyncList = waitSyncList.stream()
+ .filter(w -> mMySync.pendingSync.get(w))
+ .collect(Collectors.toList());
+ handledSyncList.forEach(w -> mMySync.pendingSync.clear(w));
+ waitSyncList.removeAll(handledSyncList);
+ if (waitSyncList.isEmpty()) {
+ break;
+ }
try {
mMySync.wait(WAIT_MSEC);
} catch (InterruptedException e) { }
}
+ if (!waitSyncList.isEmpty()) {
+ Log.i(TAG, "Missing broadcast: " + waitSyncList);
+ }
+ return waitSyncList.isEmpty();
+ }
+ }
+
+ private boolean waitForBroadcasts(int waitSingleSync) {
+ return waitForBroadcasts(
+ new LinkedList<Integer>(Arrays.asList(waitSingleSync)));
+ }
+
+ private boolean waitForServiceResponse(MyResponse waitResponse) {
+ synchronized (waitResponse) {
+ long timeout = System.currentTimeMillis() + TIMEOUT_MSEC;
+ while (System.currentTimeMillis() < timeout) {
+ try {
+ waitResponse.wait(WAIT_MSEC);
+ } catch (InterruptedException e) { }
+
+ if (waitResponse.valid) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ // Return true if location is enabled.
+ private boolean isLocationEnabled() {
+ return Settings.Secure.getInt(getContext().getContentResolver(),
+ Settings.Secure.LOCATION_MODE, Settings.Secure.LOCATION_MODE_OFF)
+ != Settings.Secure.LOCATION_MODE_OFF;
+ }
+
+ // Returns true if the device has location feature.
+ private boolean hasLocationFeature() {
+ return getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOCATION);
+ }
+
+ private void resetResponse(MyResponse responseObj) {
+ synchronized (responseObj) {
+ responseObj.valid = false;
+ responseObj.networkInfo = null;
}
}
@@ -148,25 +249,212 @@
cm.unregisterNetworkCallback(networkCallback);
}
- public void testConcurrency() {
+ private boolean setupWifiP2p() {
// Cannot support p2p alone
if (!WifiFeature.isWifiSupported(getContext())) {
assertTrue(!WifiFeature.isP2pSupported(getContext()));
- return;
+ return false;
}
if (!WifiFeature.isP2pSupported(getContext())) {
// skip the test if p2p is not supported
+ return false;
+ }
+
+ if (!hasLocationFeature()) {
+ Log.d(TAG, "Skipping test as location is not supported");
+ return false;
+ }
+ if (!isLocationEnabled()) {
+ fail("Please enable location for this test - since P-release WiFi Direct"
+ + " needs Location enabled.");
+ }
+
+ long timeout = System.currentTimeMillis() + TIMEOUT_MSEC;
+ while (!mWifiManager.isWifiEnabled() && System.currentTimeMillis() < timeout) {
+ try {
+ enableWifi();
+ } catch (InterruptedException e) { }
+ }
+
+ assertTrue(mWifiManager.isWifiEnabled());
+
+ assertTrue(waitForBroadcasts(
+ new LinkedList<Integer>(
+ Arrays.asList(MySync.WIFI_STATE, MySync.P2P_STATE))));
+
+ assertEquals(WifiManager.WIFI_STATE_ENABLED, mMySync.expectedWifiState);
+ assertEquals(WifiP2pManager.WIFI_P2P_STATE_ENABLED, mMySync.expectedP2pState);
+
+ mWifiP2pManager =
+ (WifiP2pManager) getContext().getSystemService(Context.WIFI_P2P_SERVICE);
+ mWifiP2pChannel = mWifiP2pManager.initialize(
+ getContext(), getContext().getMainLooper(), null);
+
+ assertNotNull(mWifiP2pManager);
+ assertNotNull(mWifiP2pChannel);
+
+ assertTrue(waitForBroadcasts(MySync.NETWORK_INFO));
+ // wait for changing to EnabledState
+ assertNotNull(mMySync.expectedNetworkInfo);
+ assertTrue(mMySync.expectedNetworkInfo.isAvailable());
+
+ return true;
+ }
+
+ public void testConcurrency() {
+ if (!setupWifiP2p()) {
return;
}
- // Enable wifi
- SystemUtil.runShellCommand("svc wifi enable");
+ resetResponse(mMyResponse);
+ mWifiP2pManager.requestP2pState(mWifiP2pChannel, new WifiP2pManager.P2pStateListener() {
+ @Override
+ public void onP2pStateAvailable(int state) {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.p2pState = state;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertEquals(WifiP2pManager.WIFI_P2P_STATE_ENABLED, mMyResponse.p2pState);
+ }
- waitForBroadcasts();
+ public void testRequestDiscoveryState() {
+ if (!setupWifiP2p()) {
+ return;
+ }
- assertTrue(mMySync.expectedWifiState == WifiManager.WIFI_STATE_ENABLED);
- assertTrue(mMySync.expectedP2pState == WifiP2pManager.WIFI_P2P_STATE_ENABLED);
+ resetResponse(mMyResponse);
+ mWifiP2pManager.requestDiscoveryState(
+ mWifiP2pChannel, new WifiP2pManager.DiscoveryStateListener() {
+ @Override
+ public void onDiscoveryStateAvailable(int state) {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.discoveryState = state;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertEquals(WifiP2pManager.WIFI_P2P_DISCOVERY_STOPPED, mMyResponse.discoveryState);
+
+ resetResponse(mMyResponse);
+ mWifiP2pManager.discoverPeers(mWifiP2pChannel, new WifiP2pManager.ActionListener() {
+ @Override
+ public void onSuccess() {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.success = true;
+ mMyResponse.notify();
+ }
+ }
+
+ @Override
+ public void onFailure(int reason) {
+ synchronized (mMyResponse) {
+ Log.d(TAG, "discoveryPeers failure reason: " + reason);
+ mMyResponse.valid = true;
+ mMyResponse.success = false;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertTrue(mMyResponse.success);
+ assertTrue(waitForBroadcasts(MySync.DISCOVERY_STATE));
+
+ resetResponse(mMyResponse);
+ mWifiP2pManager.requestDiscoveryState(mWifiP2pChannel,
+ new WifiP2pManager.DiscoveryStateListener() {
+ @Override
+ public void onDiscoveryStateAvailable(int state) {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.discoveryState = state;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertEquals(WifiP2pManager.WIFI_P2P_DISCOVERY_STARTED, mMyResponse.discoveryState);
+
+ mWifiP2pManager.stopPeerDiscovery(mWifiP2pChannel, null);
+ }
+
+ public void testRequestNetworkInfo() {
+ if (!setupWifiP2p()) {
+ return;
+ }
+
+ resetResponse(mMyResponse);
+ mWifiP2pManager.requestNetworkInfo(mWifiP2pChannel,
+ new WifiP2pManager.NetworkInfoListener() {
+ @Override
+ public void onNetworkInfoAvailable(NetworkInfo info) {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.networkInfo = info;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertNotNull(mMyResponse.networkInfo);
+ // The state might be IDLE, DISCONNECTED, FAILED before a connection establishment.
+ // Just ensure the state is NOT CONNECTED.
+ assertNotEquals(NetworkInfo.DetailedState.CONNECTED,
+ mMySync.expectedNetworkInfo.getDetailedState());
+
+ resetResponse(mMyResponse);
+ mWifiP2pManager.createGroup(mWifiP2pChannel, new WifiP2pManager.ActionListener() {
+ @Override
+ public void onSuccess() {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.success = true;
+ mMyResponse.notify();
+ }
+ }
+
+ @Override
+ public void onFailure(int reason) {
+ synchronized (mMyResponse) {
+ Log.d(TAG, "createGroup failure reason: " + reason);
+ mMyResponse.valid = true;
+ mMyResponse.success = false;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertTrue(mMyResponse.success);
+ assertTrue(waitForBroadcasts(MySync.NETWORK_INFO));
+ assertNotNull(mMySync.expectedNetworkInfo);
+ assertEquals(NetworkInfo.DetailedState.CONNECTED,
+ mMySync.expectedNetworkInfo.getDetailedState());
+
+ resetResponse(mMyResponse);
+ mWifiP2pManager.requestNetworkInfo(mWifiP2pChannel,
+ new WifiP2pManager.NetworkInfoListener() {
+ @Override
+ public void onNetworkInfoAvailable(NetworkInfo info) {
+ synchronized (mMyResponse) {
+ mMyResponse.valid = true;
+ mMyResponse.networkInfo = info;
+ mMyResponse.notify();
+ }
+ }
+ });
+ assertTrue(waitForServiceResponse(mMyResponse));
+ assertNotNull(mMyResponse.networkInfo);
+ assertEquals(NetworkInfo.DetailedState.CONNECTED,
+ mMyResponse.networkInfo.getDetailedState());
+
+ mWifiP2pManager.removeGroup(mWifiP2pChannel, null);
}
}
diff --git a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
index 4297a73..a66fcdb 100644
--- a/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/WifiManagerTest.java
@@ -28,7 +28,6 @@
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
-import android.net.wifi.WifiConfiguration.Status;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.TxPacketCountListener;
import android.net.wifi.WifiManager.WifiLock;
@@ -38,24 +37,21 @@
import android.os.Process;
import android.os.SystemClock;
import android.provider.Settings;
-import android.support.test.InstrumentationRegistry;
import android.support.test.uiautomator.UiDevice;
import android.test.AndroidTestCase;
-import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Log;
+import androidx.test.InstrumentationRegistry;
+
import com.android.compatibility.common.util.SystemUtil;
-import com.android.compatibility.common.util.WifiConfigCreator;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.security.cert.X509Certificate;
-import java.util.HashSet;
import java.util.List;
import java.util.Objects;
-import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
@@ -771,6 +767,15 @@
TestLocalOnlyHotspotCallback callback = startLocalOnlyHotspot();
+ // add sleep to avoid calling stopLocalOnlyHotspot before TetherController initialization.
+ // TODO: remove this sleep as soon as b/124330089 is fixed.
+ try {
+ Log.d(TAG, "Sleep for 2 seconds");
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ Log.d(TAG, "Thread InterruptedException!");
+ }
+
stopLocalOnlyHotspot(callback, wifiEnabled);
// wifi should either stay on, or come back on
@@ -846,6 +851,15 @@
}
assertTrue(caughtException);
+ // add sleep to avoid calling stopLocalOnlyHotspot before TetherController initialization.
+ // TODO: remove this sleep as soon as b/124330089 is fixed.
+ try {
+ Log.d(TAG, "Sleep for 2 seconds");
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ Log.d(TAG, "Thread InterruptedException!");
+ }
+
stopLocalOnlyHotspot(callback, wifiEnabled);
}