Merge "Remove some crufty "core" tests." (7bd28de5) · Commits · e / os / android_frameworks_base

tests/CoreTests/android/core/InetAddrTest.java

deleted100644 → 0

+0 −100

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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.core;

		import junit.framework.TestCase;

		import java.net.InetAddress;
		import java.net.UnknownHostException;
		import java.util.Random;

		import android.test.suitebuilder.annotation.Suppress;

		/**
		* Tests InetAddr class by checking methods to resolve domains to IP addresses
		* and by checking if the class returns correct addresses for local host address
		* and host name.
		*/
		@Suppress
		public class InetAddrTest extends TestCase {
		private static final String[] HOSTS = {
		"localhost", "www.google.com", "www.slashdot.org", "www.wikipedia.org",
		"www.paypal.com", "www.cnn.com", "www.yahoo.com", "www.amazon.com",
		"www.ebay.com", "www.android.com"
		};

		public void testInetAddr() throws Exception {
		byte[] raw;

		InetAddress ia = InetAddress.getByName("localhost");

		raw = ia.getAddress();

		assertEquals(127, raw[0]);
		assertEquals(0, raw[1]);
		assertEquals(0, raw[2]);
		assertEquals(1, raw[3]);

		ia = InetAddress.getByName("127.0.0.1");

		raw = ia.getAddress();

		assertEquals(127, raw[0]);
		assertEquals(0, raw[1]);
		assertEquals(0, raw[2]);
		assertEquals(1, raw[3]);

		ia = InetAddress.getByName(null);

		try {
		InetAddress.getByName(".0.0.1");
		fail("expected ex");
		} catch (UnknownHostException ex) {
		// expected
		}

		try {
		InetAddress.getByName("thereisagoodchancethisdomaindoesnotexist.weirdtld");
		fail("expected ex");
		} catch (UnknownHostException ex) {
		// expected
		}

		try {
		InetAddress.getByName("127.0.0.");
		fail("expected ex");
		} catch (UnknownHostException ex) {
		// expected
		}

		Random random = new Random();
		int count = 0;
		for (int i = 0; i < 100; i++) {
		int index = random.nextInt(HOSTS.length);
		try {
		InetAddress.getByName(HOSTS[index]);
		count++;
		try {
		Thread.sleep(50);
		} catch (InterruptedException ex) {
		}
		} catch (UnknownHostException ex) {
		}
		}
		assertEquals("Not all host lookups succeeded", 100, count);
		}
		}

tests/CoreTests/android/core/SSLSocketTest.java

deleted100644 → 0

+0 −1094

File deleted.

Preview size limit exceeded, changes collapsed.

tests/CoreTests/android/core/SocketTest.java

deleted100644 → 0

+0 −294

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 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.core;

		import junit.framework.Assert;
		import junit.framework.TestCase;

		import java.io.IOException;
		import java.net.InetAddress;
		import java.net.InetSocketAddress;
		import java.net.ServerSocket;
		import java.net.Socket;
		import java.net.SocketException;
		import java.net.SocketTimeoutException;
		import java.nio.channels.SocketChannel;
		import java.util.concurrent.Semaphore;

		import android.test.suitebuilder.annotation.LargeTest;
		import android.test.suitebuilder.annotation.SmallTest;
		import android.test.suitebuilder.annotation.Suppress;

		/**
		* Regression tests for various socket related problems. And a few general
		* socket tests.
		*/
		public class SocketTest extends TestCase {

		private static final String NON_EXISTING_ADDRESS = "123.123.123.123";

		private static final String KNOW_GOOD_ADDRESS = "209.85.129.147";

		private static final String PACKAGE_DROPPING_ADDRESS = "191.167.0.1";

		// Test for basic bind/connect/accept behavior.
		@SmallTest
		public void testSocketSimple() throws Exception {
		ServerSocket ss;
		Socket s, s1;
		int port;

		IOException lastEx = null;

		ss = new ServerSocket();

		for (port = 9900; port < 9999; port++) {
		try {
		ss.bind(new InetSocketAddress("127.0.0.1", port));
		lastEx = null;
		break;
		} catch (IOException ex) {
		lastEx = ex;
		}
		}

		if (lastEx != null) {
		throw lastEx;
		}

		s = new Socket("127.0.0.1", port);

		s1 = ss.accept();

		s.getOutputStream().write(0xa5);

		assertEquals(0xa5, s1.getInputStream().read());

		s1.getOutputStream().write(0x5a);
		assertEquals(0x5a, s.getInputStream().read());
		}

		// Regression test for #820068: Wildcard address
		@SmallTest
		public void testWildcardAddress() throws Exception {
		Socket s2 = new Socket();
		s2.bind(new InetSocketAddress((InetAddress) null, 12345));
		byte[] addr = s2.getLocalAddress().getAddress();
		for (int i = 0; i < 4; i++) {
		assertEquals("Not the wildcard address", 0, addr[i]);
		}
		}

		// Regression test for #865753: server sockets not closing properly
		@SmallTest
		public void testServerSocketClose() throws Exception {
		ServerSocket s3 = new ServerSocket(23456);
		s3.close();
		ServerSocket s4 = new ServerSocket(23456);
		s4.close();
		}

		// Regression test for #876985: SO_REUSEADDR not working properly

		private Exception serverError = null;

		@LargeTest
		public void testSetReuseAddress() throws IOException {
		InetSocketAddress addr = new InetSocketAddress(8383);

		final ServerSocket serverSock = new ServerSocket();
		serverSock.setReuseAddress(true);
		serverSock.bind(addr);

		final Semaphore semThreadEnd = new Semaphore(0);
		new Thread() {
		@Override
		public void run() {
		try {
		Socket sock = serverSock.accept();
		sock.getInputStream().read();
		sock.close();
		} catch (IOException e) {
		serverError = e;
		}
		semThreadEnd.release();
		}
		}.start();

		// Give the server a bit of time for startup
		try {
		Thread.sleep(2000);
		} catch (InterruptedException ex) {
		// Ignored.
		}

		Socket client = new Socket("localhost", 8383);
		client.getOutputStream().write(1);
		// Just leave this connection open from the client side. It will be
		// closed from the server side so the server stays in the TIME_WAIT
		// state for a while. setReuseAddress() should be able to handle this.

		try {
		semThreadEnd.acquire();
		} catch (InterruptedException e) {
		// ignore
		}
		serverSock.close();

		ServerSocket serverSock2 = new ServerSocket();
		serverSock2.setReuseAddress(true);
		serverSock2.bind(addr);
		serverSock2.close();

		if (serverError != null) {
		throw new RuntimeException("Server must complete without error", serverError);
		}
		}

		// Regression for 916701, a wrong exception was thrown after timeout of
		// a ServerSocket.
		@LargeTest
		public void testTimeoutException() throws IOException {
		ServerSocket s = new ServerSocket(9800);
		s.setSoTimeout(2000);
		try {
		s.accept();
		} catch (SocketTimeoutException e) {
		// this is ok.
		}
		}

		// Regression for issue 1001980, openening a SocketChannel threw an Exception
		@SmallTest
		public void testNativeSocketChannelOpen() throws IOException {
		SocketChannel.open();
		}

		// Regression test for issue 1018016, connecting ignored a set timeout.
		//
		// Disabled because test behaves differently depending on networking
		// environment. It works fine in the emulator and one the device with
		// WLAN, but when 3G comes into play, the possible existence of a
		// proxy makes it fail.
		//
		// @LargeTest
		// public void testSocketSetSOTimeout() throws IOException {
		// Socket sock = new Socket();
		// int timeout = 5000;
		// long start = System.currentTimeMillis();
		// try {
		// sock.connect(new InetSocketAddress(NON_EXISTING_ADDRESS, 80), timeout);
		// } catch (SocketTimeoutException e) {
		// // expected
		// long delay = System.currentTimeMillis() - start;
		// if (Math.abs(delay - timeout) > 1000) {
		// fail("timeout was not accurate. expected: " + timeout
		// + " actual: " + delay + " miliseconds.");
		// }
		// } finally {
		// try {
		// sock.close();
		// } catch (IOException ioe) {
		// // ignore
		// }
		// }
		// }

		/**
		* Regression test for 1062928: Dotted IP addresses (e.g., 192.168.100.1)
		* appear to be broken in the M5 SDK.
		*
		* Tests that a connection given a ip-addressv4 such as 192.168.100.100 does
		* not fail - sdk m5 seems only to accept dns names instead of ip numbers.
		* ip 209.85.129.147 (one address of www.google.com) on port 80 (http) is
		* used to test the connection.
		*/

		// Commenting out this test since it is flaky, even at the best of times. See
		// #1191317 for Info.
		@Suppress
		public void disable_testConnectWithIP4IPAddr() {
		// call a Google Web server
		InetSocketAddress scktAddrss = new InetSocketAddress(KNOW_GOOD_ADDRESS,
		80);
		Socket clntSckt = new Socket();
		try {
		clntSckt.connect(scktAddrss, 5000);
		} catch (Throwable e) {
		fail("connection problem:" + e.getClass().getName() + ": "
		+ e.getMessage());
		} finally {
		try {
		clntSckt.close();
		} catch (Exception e) {
		// ignore
		}
		}
		}


		// Regression test for #1058962: Socket.close() does not cause
		// socket.connect() to return immediately.
		private Socket client;

		private Exception error;

		private boolean connected;

		// This test isn't working now, but really should work.
		// TODO Enable this test again.

		@Suppress
		public void disable_testSocketConnectClose() {
		try {
		client = new Socket();

		new Thread() {
		@Override
		public void run() {
		try {
		client.connect(new InetSocketAddress(PACKAGE_DROPPING_ADDRESS, 1357));
		} catch (Exception ex) {
		error = ex;
		}

		connected = true;
		}
		}.start();

		Thread.sleep(1000);

		Assert.assertNull("Connect must not fail immediately. Maybe try different address.", error);
		Assert.assertFalse("Connect must not succeed. Maybe try different address.", connected);

		client.close();

		Thread.sleep(1000);

		if (error == null) {
		fail("Socket connect still ongoing");
		} else if (!(error instanceof SocketException)) {
		fail("Socket connect interrupted with wrong error: " + error.toString());
		}

		} catch (Exception ex) {
		throw new RuntimeException(ex);
		}

		}

		}