Merge remote branch 'korg/eclair' into eclairmerge
Conflicts:
tests/AndroidManifest.xml
tests/jni/Android.mk
tests/res/layout/focus_finder_layout.xml
tests/res/values/strings.xml
tests/src/android/opengl/cts/OpenGlEsVersionStubActivity.java
tests/src/android/os/cts/CpuFeatures.java
tests/src/android/view/cts/FocusFinderStubActivity.java
tests/tests/app/src/android/app/cts/SystemFeaturesTest.java
tests/tests/os/src/android/os/cts/BuildTest.java
tests/tests/permission/src/android/permission/cts/DebuggableTest.java
tools/device-setup/TestDeviceSetup/src/android/tests/getinfo/DeviceInfoInstrument.java
tools/host/src/com/android/cts/TestDevice.java
tools/host/src/com/android/cts/TestSessionLog.java
tools/host/src/com/android/cts/Version.java
tools/host/src/res/cts_result.xsl
Change-Id: If7cd43b18be79a062d23d5536a3ff3a91c635f0b
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index edcea9a..3b85e9f 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -22,20 +22,35 @@
import dalvik.annotation.TestTargets;
import dalvik.annotation.ToBeFixed;
+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.NetworkInfo;
import android.net.NetworkInfo.DetailedState;
import android.net.NetworkInfo.State;
+import android.net.wifi.WifiManager;
import android.test.AndroidTestCase;
+import android.util.Log;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
@TestTargetClass(ConnectivityManager.class)
public class ConnectivityManagerTest extends AndroidTestCase {
+ private static final String TAG = ConnectivityManagerTest.class.getSimpleName();
+
+ private static final String FEATURE_ENABLE_HIPRI = "enableHIPRI";
+
public static final int TYPE_MOBILE = ConnectivityManager.TYPE_MOBILE;
public static final int TYPE_WIFI = ConnectivityManager.TYPE_WIFI;
private static final int HOST_ADDRESS = 0x7f000001;// represent ip 127.0.0.1
private ConnectivityManager mCm;
+ private WifiManager mWifiManager;
+ private PackageManager mPackageManager;
// must include both mobile data + wifi
private static final int MIN_NUM_NETWORK_TYPES = 2;
@@ -43,6 +58,8 @@
protected void setUp() throws Exception {
super.setUp();
mCm = (ConnectivityManager) getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
+ mWifiManager = (WifiManager) getContext().getSystemService(Context.WIFI_SERVICE);
+ mPackageManager = getContext().getPackageManager();
}
@TestTargetNew(
@@ -204,8 +221,8 @@
NetworkInfo[] ni = mCm.getAllNetworkInfo();
for (NetworkInfo n : ni) {
- // make sure network is up
- if (n.isConnected()) {
+ // make sure network is up (except WIFI due to always fail)
+ if (n.isConnected() && (n.getType() != TYPE_WIFI)) {
assertTrue(mCm.requestRouteToHost(n.getType(), HOST_ADDRESS));
}
}
@@ -235,4 +252,91 @@
public void testTest() {
mCm.getBackgroundDataSetting();
}
+
+ /** Test that hipri can be brought up when Wifi is enabled. */
+ public void testStartUsingNetworkFeature_enableHipri() throws Exception {
+ if (!mPackageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)
+ || !mPackageManager.hasSystemFeature(PackageManager.FEATURE_WIFI)) {
+ // This test requires a mobile data connection and WiFi.
+ return;
+ }
+
+ boolean isWifiConnected = mWifiManager.isWifiEnabled()
+ && mWifiManager.getConnectionInfo().getSSID() != null;
+
+ try {
+ // Make sure WiFi is connected to an access point.
+ if (!isWifiConnected) {
+ connectToWifi();
+ }
+
+ // Register a receiver that will capture the connectivity change for hipri.
+ ConnectivityActionReceiver receiver =
+ new ConnectivityActionReceiver(ConnectivityManager.TYPE_MOBILE_HIPRI);
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+ mContext.registerReceiver(receiver, filter);
+
+ // Try to start using the hipri feature...
+ int result = mCm.startUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE,
+ FEATURE_ENABLE_HIPRI);
+ assertTrue("Couldn't start using the HIPRI feature.", result != -1);
+
+ // Check that the ConnectivityManager reported that it connected using hipri...
+ assertTrue("Couldn't connect using hipri...", receiver.waitForConnection());
+
+ assertTrue("Couldn't requestRouteToHost using HIPRI.",
+ mCm.requestRouteToHost(ConnectivityManager.TYPE_MOBILE_HIPRI, HOST_ADDRESS));
+
+ } catch (InterruptedException e) {
+ fail("Broadcast receiver waiting for ConnectivityManager interrupted.");
+ } finally {
+ mCm.stopUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE,
+ FEATURE_ENABLE_HIPRI);
+ if (!isWifiConnected) {
+ mWifiManager.setWifiEnabled(false);
+ }
+ }
+ }
+
+ private void connectToWifi() throws InterruptedException {
+ ConnectivityActionReceiver receiver =
+ new ConnectivityActionReceiver(ConnectivityManager.TYPE_WIFI);
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+ mContext.registerReceiver(receiver, filter);
+
+ assertTrue(mWifiManager.setWifiEnabled(true));
+ assertTrue("Wifi must be configured to connect to an access point for this test.",
+ receiver.waitForConnection());
+
+ mContext.unregisterReceiver(receiver);
+ }
+
+ /** Receiver that captures the last connectivity change's network type and state. */
+ private class ConnectivityActionReceiver extends BroadcastReceiver {
+
+ private final CountDownLatch mReceiveLatch = new CountDownLatch(1);
+
+ private final int mNetworkType;
+
+ ConnectivityActionReceiver(int networkType) {
+ mNetworkType = networkType;
+ }
+
+ public void onReceive(Context context, Intent intent) {
+ NetworkInfo networkInfo = intent.getExtras()
+ .getParcelable(ConnectivityManager.EXTRA_NETWORK_INFO);
+ int networkType = networkInfo.getType();
+ State networkState = networkInfo.getState();
+ Log.i(TAG, "Network type: " + networkType + " state: " + networkState);
+ if (networkType == mNetworkType && networkInfo.getState() == State.CONNECTED) {
+ mReceiveLatch.countDown();
+ }
+ }
+
+ public boolean waitForConnection() throws InterruptedException {
+ return mReceiveLatch.await(10, TimeUnit.SECONDS);
+ }
+ }
}
diff --git a/tests/cts/net/src/android/net/cts/NetworkInfoTest.java b/tests/cts/net/src/android/net/cts/NetworkInfoTest.java
index d2de4e4..99e8e15 100644
--- a/tests/cts/net/src/android/net/cts/NetworkInfoTest.java
+++ b/tests/cts/net/src/android/net/cts/NetworkInfoTest.java
@@ -32,7 +32,7 @@
public static final int TYPE_MOBILE = ConnectivityManager.TYPE_MOBILE;
public static final int TYPE_WIFI = ConnectivityManager.TYPE_WIFI;
- public static final String MOBILE_TYPE_NAME = "MOBILE";
+ public static final String MOBILE_TYPE_NAME = "mobile";
public static final String WIFI_TYPE_NAME = "WIFI";
@TestTargets({
diff --git a/tests/cts/net/src/android/net/cts/ProxyTest.java b/tests/cts/net/src/android/net/cts/ProxyTest.java
index 357935a..0c0586e 100644
--- a/tests/cts/net/src/android/net/cts/ProxyTest.java
+++ b/tests/cts/net/src/android/net/cts/ProxyTest.java
@@ -16,29 +16,17 @@
package android.net.cts;
-import android.content.Context;
-import android.net.Proxy;
-import android.provider.Settings.Secure;
-import android.test.AndroidTestCase;
-
-import dalvik.annotation.BrokenTest;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
+import android.net.Proxy;
+import android.test.AndroidTestCase;
+
@TestTargetClass(Proxy.class)
public class ProxyTest extends AndroidTestCase {
- private Context mContext;
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
-
- mContext = getContext();
- }
-
@TestTargetNew(
level = TestLevel.COMPLETE,
method = "Proxy",
@@ -58,19 +46,8 @@
level = TestLevel.COMPLETE,
method = "getDefaultHost",
args = {}
- ),
- @TestTargetNew(
- level = TestLevel.COMPLETE,
- method = "getPort",
- args = {Context.class}
- ),
- @TestTargetNew(
- level = TestLevel.COMPLETE,
- method = "getHost",
- args = {Context.class}
)
})
- @BrokenTest("Cannot write secure settings table")
public void testAccessProperties() {
final int minValidPort = 0;
final int maxValidPort = 65535;
@@ -80,12 +57,5 @@
} else {
assertTrue(defaultPort >= minValidPort && defaultPort <= maxValidPort);
}
-
- final String host = "proxy.example.com";
- final int port = 2008;
-
- Secure.putString(mContext.getContentResolver(), Secure.HTTP_PROXY, host + ":" + port);
- assertEquals(host, Proxy.getHost(mContext));
- assertEquals(port, Proxy.getPort(mContext));
}
}
diff --git a/tests/cts/net/src/android/net/cts/TrafficStatsTest.java b/tests/cts/net/src/android/net/cts/TrafficStatsTest.java
new file mode 100644
index 0000000..9d23a87
--- /dev/null
+++ b/tests/cts/net/src/android/net/cts/TrafficStatsTest.java
@@ -0,0 +1,225 @@
+/*
+ * 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.
+ */
+
+package android.net.cts;
+
+import android.os.Process;
+import android.net.TrafficStats;
+import android.test.AndroidTestCase;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.util.Random;
+
+@TestTargetClass(TrafficStats.class)
+public class TrafficStatsTest extends AndroidTestCase {
+ @TestTargets({
+ @TestTargetNew(level = TestLevel.SUFFICIENT, method = "getMobileTxPackets"),
+ @TestTargetNew(level = TestLevel.SUFFICIENT, method = "getMobileRxPackets"),
+ @TestTargetNew(level = TestLevel.SUFFICIENT, method = "getMobileTxBytes"),
+ @TestTargetNew(level = TestLevel.SUFFICIENT, method = "getMobileRxBytes")
+ })
+ public void testGetMobileStats() {
+ // We can't assume a mobile network is even present in this test, so
+ // we simply assert that a valid value is returned.
+
+ assertTrue(TrafficStats.getMobileTxPackets() == TrafficStats.UNSUPPORTED ||
+ TrafficStats.getMobileTxPackets() >= 0);
+ assertTrue(TrafficStats.getMobileRxPackets() == TrafficStats.UNSUPPORTED ||
+ TrafficStats.getMobileRxPackets() >= 0);
+ assertTrue(TrafficStats.getMobileTxBytes() == TrafficStats.UNSUPPORTED ||
+ TrafficStats.getMobileTxBytes() >= 0);
+ assertTrue(TrafficStats.getMobileRxBytes() == TrafficStats.UNSUPPORTED ||
+ TrafficStats.getMobileRxBytes() >= 0);
+ }
+
+ @TestTargets({
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalTxPackets"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalRxPackets"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalTxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalRxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getUidTxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getUidRxBytes")
+ })
+ public void testTrafficStatsWithHostLookup() {
+ long txPacketsBefore = TrafficStats.getTotalTxPackets();
+ long rxPacketsBefore = TrafficStats.getTotalRxPackets();
+ long txBytesBefore = TrafficStats.getTotalTxBytes();
+ long rxBytesBefore = TrafficStats.getTotalRxBytes();
+ long uidTxBytesBefore = TrafficStats.getUidTxBytes(Process.myUid());
+ long uidRxBytesBefore = TrafficStats.getUidRxBytes(Process.myUid());
+
+ // Look up random hostnames in a wildcard domain owned by Google.
+ // This will require a DNS request, which should generate traffic.
+
+ int found = 0;
+ Random r = new Random();
+ for (int i = 0; i < 10; i++) {
+ try {
+ String host = "test" + r.nextInt(100000) + ".clients.google.com";
+ InetAddress[] addr = InetAddress.getAllByName(host);
+ if (addr.length > 0) found++;
+ } catch (UnknownHostException e) {
+ // Ignore -- our purpose is not to test network connectivity,
+ // and we'd rather have false positives than a flaky test.
+ }
+ }
+
+ long txPacketsAfter = TrafficStats.getTotalTxPackets();
+ long rxPacketsAfter = TrafficStats.getTotalRxPackets();
+ long txBytesAfter = TrafficStats.getTotalTxBytes();
+ long rxBytesAfter = TrafficStats.getTotalRxBytes();
+ long uidTxBytesAfter = TrafficStats.getUidTxBytes(Process.myUid());
+ long uidRxBytesAfter = TrafficStats.getUidRxBytes(Process.myUid());
+
+ // Make some conservative assertions about the data used:
+ // each successful resolution should exchange at least one packet,
+ // and at least 20 bytes in each direction.
+
+ assertTrue("txp: " + txPacketsBefore + " [" + found + "] " + txPacketsAfter,
+ txPacketsAfter >= txPacketsBefore + found);
+ assertTrue("rxp: " + rxPacketsBefore + " [" + found + "] " + rxPacketsAfter,
+ rxPacketsAfter >= rxPacketsBefore + found);
+ assertTrue("txb: " + txBytesBefore + " [" + found + "] " + txBytesAfter,
+ txBytesAfter >= txBytesBefore + found * 20);
+ assertTrue("rxb: " + rxBytesBefore + " [" + found + "] " + rxBytesAfter,
+ rxBytesAfter >= rxBytesBefore + found * 20);
+ assertTrue("uidtxb: " + uidTxBytesBefore + " [" + found + "] " + uidTxBytesAfter,
+ uidTxBytesAfter >= uidTxBytesBefore + found * 20);
+ assertTrue("uidrxb: " + uidRxBytesBefore + " [" + found + "] " + uidRxBytesAfter,
+ uidRxBytesAfter >= uidRxBytesBefore + found * 20);
+ }
+
+ @TestTargets({
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getMobileTxPackets"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getMobileRxPackets"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getMobileTxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getMobileRxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalTxPackets"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalRxPackets"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalTxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getTotalRxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getUidTxBytes"),
+ @TestTargetNew(level = TestLevel.PARTIAL_COMPLETE, method = "getUidRxBytes")
+ })
+ public void testTrafficStatsForLocalhost() throws IOException {
+ long mobileTxPacketsBefore = TrafficStats.getTotalTxPackets();
+ long mobileRxPacketsBefore = TrafficStats.getTotalRxPackets();
+ long mobileTxBytesBefore = TrafficStats.getTotalTxBytes();
+ long mobileRxBytesBefore = TrafficStats.getTotalRxBytes();
+ long totalTxPacketsBefore = TrafficStats.getTotalTxPackets();
+ long totalRxPacketsBefore = TrafficStats.getTotalRxPackets();
+ long totalTxBytesBefore = TrafficStats.getTotalTxBytes();
+ long totalRxBytesBefore = TrafficStats.getTotalRxBytes();
+ long uidTxBytesBefore = TrafficStats.getUidTxBytes(Process.myUid());
+ long uidRxBytesBefore = TrafficStats.getUidRxBytes(Process.myUid());
+
+ // Transfer 1MB of data across an explicitly localhost socket.
+
+ final ServerSocket server = new ServerSocket(0);
+ new Thread("TrafficStatsTest.testTrafficStatsForLocalhost") {
+ @Override
+ public void run() {
+ try {
+ Socket socket = new Socket("localhost", server.getLocalPort());
+ OutputStream out = socket.getOutputStream();
+ byte[] buf = new byte[1024];
+ for (int i = 0; i < 1024; i++) out.write(buf);
+ out.close();
+ socket.close();
+ } catch (IOException e) {
+ }
+ }
+ }.start();
+
+ try {
+ Socket socket = server.accept();
+ InputStream in = socket.getInputStream();
+ byte[] buf = new byte[1024];
+ int read = 0;
+ while (read < 1048576) {
+ int n = in.read(buf);
+ assertTrue("Unexpected EOF", n > 0);
+ read += n;
+ }
+ } finally {
+ server.close();
+ }
+
+ // It's too fast to call getUidTxBytes function.
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ }
+
+ long mobileTxPacketsAfter = TrafficStats.getTotalTxPackets();
+ long mobileRxPacketsAfter = TrafficStats.getTotalRxPackets();
+ long mobileTxBytesAfter = TrafficStats.getTotalTxBytes();
+ long mobileRxBytesAfter = TrafficStats.getTotalRxBytes();
+ long totalTxPacketsAfter = TrafficStats.getTotalTxPackets();
+ long totalRxPacketsAfter = TrafficStats.getTotalRxPackets();
+ long totalTxBytesAfter = TrafficStats.getTotalTxBytes();
+ long totalRxBytesAfter = TrafficStats.getTotalRxBytes();
+ long uidTxBytesAfter = TrafficStats.getUidTxBytes(Process.myUid());
+ long uidRxBytesAfter = TrafficStats.getUidRxBytes(Process.myUid());
+
+ // Localhost traffic should *not* count against mobile or total stats.
+ // There might be some other traffic, but nowhere near 1MB.
+
+ assertTrue("mtxp: " + mobileTxPacketsBefore + " -> " + mobileTxPacketsAfter,
+ mobileTxPacketsAfter >= mobileTxPacketsBefore &&
+ mobileTxPacketsAfter <= mobileTxPacketsBefore + 500);
+ assertTrue("mrxp: " + mobileRxPacketsBefore + " -> " + mobileRxPacketsAfter,
+ mobileRxPacketsAfter >= mobileRxPacketsBefore &&
+ mobileRxPacketsAfter <= mobileRxPacketsBefore + 500);
+ assertTrue("mtxb: " + mobileTxBytesBefore + " -> " + mobileTxBytesAfter,
+ mobileTxBytesAfter >= mobileTxBytesBefore &&
+ mobileTxBytesAfter <= mobileTxBytesBefore + 200000);
+ assertTrue("mrxb: " + mobileRxBytesBefore + " -> " + mobileRxBytesAfter,
+ mobileRxBytesAfter >= mobileRxBytesBefore &&
+ mobileRxBytesAfter <= mobileRxBytesBefore + 200000);
+
+ assertTrue("ttxp: " + totalTxPacketsBefore + " -> " + totalTxPacketsAfter,
+ totalTxPacketsAfter >= totalTxPacketsBefore &&
+ totalTxPacketsAfter <= totalTxPacketsBefore + 500);
+ assertTrue("trxp: " + totalRxPacketsBefore + " -> " + totalRxPacketsAfter,
+ totalRxPacketsAfter >= totalRxPacketsBefore &&
+ totalRxPacketsAfter <= totalRxPacketsBefore + 500);
+ assertTrue("ttxb: " + totalTxBytesBefore + " -> " + totalTxBytesAfter,
+ totalTxBytesAfter >= totalTxBytesBefore &&
+ totalTxBytesAfter <= totalTxBytesBefore + 200000);
+ assertTrue("trxb: " + totalRxBytesBefore + " -> " + totalRxBytesAfter,
+ totalRxBytesAfter >= totalRxBytesBefore &&
+ totalRxBytesAfter <= totalRxBytesBefore + 200000);
+
+ // Localhost traffic *does* count against per-UID stats.
+ assertTrue("uidtxb: " + uidTxBytesBefore + " -> " + uidTxBytesAfter,
+ uidTxBytesAfter >= uidTxBytesBefore + 1048576);
+ assertTrue("uidrxb: " + uidRxBytesBefore + " -> " + uidRxBytesAfter,
+ uidRxBytesAfter >= uidRxBytesBefore + 1048576);
+ }
+}
diff --git a/tests/cts/net/src/android/net/http/cts/SslCertificateTest.java b/tests/cts/net/src/android/net/http/cts/SslCertificateTest.java
index 91ca876..8bc8498 100644
--- a/tests/cts/net/src/android/net/http/cts/SslCertificateTest.java
+++ b/tests/cts/net/src/android/net/http/cts/SslCertificateTest.java
@@ -223,8 +223,7 @@
Date date1 = new Date(System.currentTimeMillis() - 1000);
Date date2 = new Date(System.currentTimeMillis());
- SslCertificate ssl = new SslCertificate("c=129", "e=weji", DateFormat.getInstance().format(
- date1), DateFormat.getInstance().format(date2));
+ SslCertificate ssl = new SslCertificate("c=129", "e=weji", date1, date2);
Bundle saved = SslCertificate.saveState(ssl);
assertTrue(saved.size() == 4);
@@ -255,13 +254,13 @@
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Test getIssuedTo().",
- method = "getValidNotAfter",
+ method = "getValidNotAfterDate",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Test getIssuedTo().",
- method = "getValidNotBefore",
+ method = "getValidNotBeforeDate",
args = {}
),
@TestTargetNew(
@@ -278,8 +277,7 @@
// new the SslCertificate instance
Date date1 = new Date(System.currentTimeMillis() - 1000);
Date date2 = new Date(System.currentTimeMillis());
- SslCertificate ssl = new SslCertificate(TO, BY, DateFormat.getInstance().format(
- date1), DateFormat.getInstance().format(date2));
+ SslCertificate ssl = new SslCertificate(TO, BY, date1, date2);
DName issuedTo = ssl.getIssuedTo();
DName issuedBy = ssl.getIssuedBy();
@@ -293,8 +291,8 @@
assertEquals("testOName", issuedBy.getOName());
assertEquals("testUName", issuedBy.getUName());
- assertEquals(DateFormat.getInstance().format(date1), ssl.getValidNotBefore());
- assertEquals(DateFormat.getInstance().format(date2), ssl.getValidNotAfter());
+ assertEquals(date1, ssl.getValidNotBeforeDate());
+ assertEquals(date2, ssl.getValidNotAfterDate());
final String EXPECTED = "Issued to: c=ccc,o=testOName,ou=testUName,cn=testCName;\n"
+ "Issued by: e=aeei,c=adb,o=testOName,ou=testUName,cn=testCName;\n";
assertEquals(EXPECTED, ssl.toString());
diff --git a/tests/cts/net/src/android/net/wifi/cts/WifiInfoTest.java b/tests/cts/net/src/android/net/wifi/cts/WifiInfoTest.java
index 42243c8..d6d7d8e 100644
--- a/tests/cts/net/src/android/net/wifi/cts/WifiInfoTest.java
+++ b/tests/cts/net/src/android/net/wifi/cts/WifiInfoTest.java
@@ -20,7 +20,6 @@
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
-import dalvik.annotation.ToBeFixed;
import android.content.BroadcastReceiver;
import android.content.Context;
@@ -168,8 +167,6 @@
args = {}
)
})
- @ToBeFixed(bug="1871573", explanation="android.net.wifi.WifiInfo#getNetworkId() return -1 when"
- + " there is wifi connection")
public void testWifiInfoProperties() throws Exception {
// this test case should in Wifi environment
WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
@@ -187,8 +184,7 @@
wifiInfo.getMacAddress();
setWifiEnabled(false);
Thread.sleep(DURATION);
- wifiInfo = mWifiManager.getConnectionInfo();
- assertEquals(-1, wifiInfo.getNetworkId());
+ assertEquals(WifiManager.WIFI_STATE_DISABLED, mWifiManager.getWifiState());
}
}