diff --git a/tests/cts/net/src/android/net/http/cts/ApacheHttpClientTest.java b/tests/cts/net/src/android/net/http/cts/ApacheHttpClientTest.java
new file mode 100644
index 0000000..e4846fd
--- /dev/null
+++ b/tests/cts/net/src/android/net/http/cts/ApacheHttpClientTest.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2011 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.http.cts;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+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.State;
+import android.net.Uri;
+import android.net.wifi.WifiManager;
+import android.test.AndroidTestCase;
+import android.util.Log;
+import android.webkit.cts.CtsTestServer;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class ApacheHttpClientTest extends AndroidTestCase {
+
+    private static final String TAG = ApacheHttpClientTest.class.getSimpleName();
+
+    private static final int NUM_DOWNLOADS = 20;
+
+    private static final int SMALL_DOWNLOAD_SIZE = 100 * 1024;
+
+    private CtsTestServer mWebServer;
+
+    private WifiManager mWifiManager;
+
+    private ConnectivityManager mConnectivityManager;
+
+    private boolean mHasTelephony;
+
+    private boolean mHasWifi;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mWebServer = new CtsTestServer(mContext);
+        mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
+        mConnectivityManager = (ConnectivityManager)
+                mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+        PackageManager packageManager = mContext.getPackageManager();
+        mHasTelephony = packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY);
+        mHasWifi = packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        mWebServer.shutdown();
+    }
+
+    public void testExecute_withMobile() throws Exception {
+        if (mHasTelephony) {
+            disconnectWifiToConnectToMobile();
+        }
+
+        downloadMultipleFiles();
+
+        if (mHasWifi) {
+            connectToWifi();
+        }
+    }
+
+    public void testExecute_withWifi() throws Exception {
+        if (mHasWifi) {
+            if (!mWifiManager.isWifiEnabled()) {
+                connectToWifi();
+            }
+            downloadMultipleFiles();
+        }
+    }
+
+    private void downloadMultipleFiles() throws ClientProtocolException, IOException {
+        List<HttpResponse> responses = new ArrayList<HttpResponse>();
+        for (int i = 0; i < NUM_DOWNLOADS; i++) {
+            HttpClient httpClient = new DefaultHttpClient();
+            HttpGet request = new HttpGet(getSmallDownloadUrl(i).toString());
+            HttpResponse response = httpClient.execute(request);
+            responses.add(response);
+        }
+
+        for (int i = 0; i < NUM_DOWNLOADS; i++) {
+            assertDownloadResponse("Download " + i, SMALL_DOWNLOAD_SIZE, responses.get(i));
+        }
+    }
+
+    private Uri getSmallDownloadUrl(int index) {
+        return Uri.parse(mWebServer.getTestDownloadUrl("cts-small-download-" + index,
+                SMALL_DOWNLOAD_SIZE));
+    }
+
+    private void assertDownloadResponse(String message, int expectedNumBytes, HttpResponse response)
+            throws IllegalStateException, IOException {
+        byte[] buffer = new byte[4096];
+        assertEquals(200, response.getStatusLine().getStatusCode());
+
+        InputStream stream = response.getEntity().getContent();
+        int numBytes = 0;
+        while (true) {
+            int bytesRead = stream.read(buffer);
+            if (bytesRead < 0) {
+                break;
+            } else {
+                numBytes += bytesRead;
+            }
+        }
+        assertEquals(message, SMALL_DOWNLOAD_SIZE, numBytes);
+    }
+
+    private void connectToWifi() throws InterruptedException {
+        if (!mWifiManager.isWifiEnabled()) {
+            ConnectivityActionReceiver receiver =
+                    new ConnectivityActionReceiver(ConnectivityManager.TYPE_WIFI, State.CONNECTED);
+            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.waitForStateChange());
+
+            mContext.unregisterReceiver(receiver);
+        }
+    }
+
+    private void disconnectWifiToConnectToMobile() throws InterruptedException {
+        if (mHasWifi && mWifiManager.isWifiEnabled()) {
+            ConnectivityActionReceiver connectMobileReceiver =
+                    new ConnectivityActionReceiver(ConnectivityManager.TYPE_MOBILE,
+                            State.CONNECTED);
+            ConnectivityActionReceiver disconnectWifiReceiver =
+                    new ConnectivityActionReceiver(ConnectivityManager.TYPE_WIFI,
+                            State.DISCONNECTED);
+            IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+            mContext.registerReceiver(connectMobileReceiver, filter);
+            mContext.registerReceiver(disconnectWifiReceiver, filter);
+
+            assertTrue(mWifiManager.setWifiEnabled(false));
+            assertTrue(disconnectWifiReceiver.waitForStateChange());
+            assertTrue(connectMobileReceiver.waitForStateChange());
+
+            mContext.unregisterReceiver(connectMobileReceiver);
+            mContext.unregisterReceiver(disconnectWifiReceiver);
+        }
+    }
+
+    /** 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;
+
+        private final State mExpectedState;
+
+        ConnectivityActionReceiver(int networkType, State expectedState) {
+            mNetworkType = networkType;
+            mExpectedState = expectedState;
+        }
+
+        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: " + networkInfo.getState());
+            if (networkType == mNetworkType && networkInfo.getState() == mExpectedState) {
+                mReceiveLatch.countDown();
+            }
+        }
+
+        public boolean waitForStateChange() throws InterruptedException {
+            return hasExpectedState() || mReceiveLatch.await(30, TimeUnit.SECONDS);
+        }
+
+        private boolean hasExpectedState() {
+            return mExpectedState == mConnectivityManager.getNetworkInfo(mNetworkType).getState();
+        }
+    }
+}