Import of Volley from GitHub to AOSP.

  - 5fb28f66748df4f89b49c1493693d1f65c6bb23e Fix NPEs/compile errors introduced by header changes. (#96) by Jeff Davidson <jpd236@cornell.edu>
  - e16a426da3bcffb1a8de1700ddbe69201540d93c Fix RequestQueueIntegrationTest flakiness. (#94) by Jeff Davidson <jpd236@cornell.edu>
  - 96feb3b09a6301b9573212027af21db7be5c8be1 Improve Volley header handling. (#91) by Jeff Davidson <jpd236@cornell.edu>
  - a794c075a62ddf438178b2e15cc79ab5502588fb For waiting requests, use ArrayList instead of LinkedList... by Ulrike Hager <uhager42@gmail.com>
  - 787ef0cc731c28b528f744dea64bd5429f99e153 Specify .aar packaging in SNAPSHOT POM. by Jeff Davidson <jpd236@cornell.edu>
  - b2bb59ab2ff08f4d468303071f050ce938349379 Fix soft TTL for duplicate requests (#73) by Ulrike Hager <uhager42@gmail.com>
  - b33a53f1793b475842f91a0fe166749118afcfc0 Deprecate Volley's use of Apache HTTP. (#75) by Jeff Davidson <jpd236@cornell.edu>

GitOrigin-RevId: 5fb28f66748df4f89b49c1493693d1f65c6bb23e
Change-Id: Ia04d2967e9923d2430a04f2474aa69ce82e114ce

12 files changed, 580 insertions, 254 deletions

diff --git a/src/test/java/com/android/volley/CacheDispatcherTest.java b/src/test/java/com/android/volley/CacheDispatcherTest.java
index 42bdda0..54886f8 100644
--- a/src/test/java/com/android/volley/CacheDispatcherTest.java
+++ b/src/test/java/com/android/volley/CacheDispatcherTest.java
@@ -112,4 +112,60 @@ public class CacheDispatcherTest {
         Request request = mNetworkQueue.take();
         assertSame(entry, request.getCacheEntry());
     }
+
+    @Test public void duplicateCacheMiss() throws Exception {
+        MockRequest secondRequest = new MockRequest();
+        mRequest.setSequence(1);
+        secondRequest.setSequence(2);
+        mCacheQueue.add(mRequest);
+        mCacheQueue.add(secondRequest);
+        mCacheQueue.waitUntilEmpty(TIMEOUT_MILLIS);
+        assertTrue(mNetworkQueue.size() == 1);
+        assertFalse(mDelivery.postResponse_called);
+    }
+
+    @Test public void duplicateSoftExpiredCacheHit_failedRequest() throws Exception {
+        Cache.Entry entry = CacheTestUtils.makeRandomCacheEntry(null, false, true);
+        mCache.setEntryToReturn(entry);
+
+        MockRequest secondRequest = new MockRequest();
+        mRequest.setSequence(1);
+        secondRequest.setSequence(2);
+
+        mCacheQueue.add(mRequest);
+        mCacheQueue.add(secondRequest);
+        mCacheQueue.waitUntilEmpty(TIMEOUT_MILLIS);
+
+        assertTrue(mNetworkQueue.size() == 1);
+        assertTrue(mDelivery.postResponse_calledNtimes == 2);
+
+        Request request = mNetworkQueue.take();
+        request.notifyListenerResponseNotUsable();
+        // Second request should now be in network queue.
+        assertTrue(mNetworkQueue.size() == 1);
+        request = mNetworkQueue.take();
+        assertTrue(request.equals(secondRequest));
+    }
+
+    @Test public void duplicateSoftExpiredCacheHit_successfulRequest() throws Exception {
+        Cache.Entry entry = CacheTestUtils.makeRandomCacheEntry(null, false, true);
+        mCache.setEntryToReturn(entry);
+
+        MockRequest secondRequest = new MockRequest();
+        mRequest.setSequence(1);
+        secondRequest.setSequence(2);
+
+        mCacheQueue.add(mRequest);
+        mCacheQueue.add(secondRequest);
+        mCacheQueue.waitUntilEmpty(TIMEOUT_MILLIS);
+
+        assertTrue(mNetworkQueue.size() == 1);
+        assertTrue(mDelivery.postResponse_calledNtimes == 2);
+
+        Request request = mNetworkQueue.take();
+        request.notifyListenerResponseReceived(Response.success(null, entry));
+        // Second request should have delivered response.
+        assertTrue(mNetworkQueue.size() == 0);
+        assertTrue(mDelivery.postResponse_calledNtimes == 3);
+    }
 }
diff --git a/src/test/java/com/android/volley/NetworkResponseTest.java b/src/test/java/com/android/volley/NetworkResponseTest.java
new file mode 100644
index 0000000..be34143
--- /dev/null
+++ b/src/test/java/com/android/volley/NetworkResponseTest.java
@@ -0,0 +1,63 @@
+package com.android.volley;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+@RunWith(RobolectricTestRunner.class)
+public class NetworkResponseTest {
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void mapToList() {
+        Map<String, String> headers = new HashMap<>();
+        headers.put("key1", "value1");
+        headers.put("key2", "value2");
+
+        NetworkResponse resp = new NetworkResponse(200, null, headers, false);
+
+        List<Header> expectedHeaders = new ArrayList<>();
+        expectedHeaders.add(new Header("key1", "value1"));
+        expectedHeaders.add(new Header("key2", "value2"));
+
+        assertThat(expectedHeaders,
+                containsInAnyOrder(resp.allHeaders.toArray(new Header[resp.allHeaders.size()])));
+    }
+
+    @Test
+    public void listToMap() {
+        List<Header> headers = new ArrayList<>();
+        headers.add(new Header("key1", "value1"));
+        // Later values should be preferred.
+        headers.add(new Header("key2", "ignoredvalue"));
+        headers.add(new Header("key2", "value2"));
+
+        NetworkResponse resp = new NetworkResponse(200, null, false, 0L, headers);
+
+        Map<String, String> expectedHeaders = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+        expectedHeaders.put("key1", "value1");
+        expectedHeaders.put("key2", "value2");
+
+        assertEquals(expectedHeaders, resp.headers);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void nullValuesDontCrash() {
+        new NetworkResponse(null);
+        new NetworkResponse(null, null);
+        new NetworkResponse(200, null, null, false);
+        new NetworkResponse(200, null, null, false, 0L);
+        new NetworkResponse(200, null, false, 0L, null);
+    }
+}
diff --git a/src/test/java/com/android/volley/RequestQueueIntegrationTest.java b/src/test/java/com/android/volley/RequestQueueIntegrationTest.java
index a73435c..304a1ab 100644
--- a/src/test/java/com/android/volley/RequestQueueIntegrationTest.java
+++ b/src/test/java/com/android/volley/RequestQueueIntegrationTest.java
@@ -22,29 +22,30 @@ import com.android.volley.mock.MockRequest;
 import com.android.volley.mock.ShadowSystemClock;
 import com.android.volley.toolbox.NoCache;
 import com.android.volley.utils.ImmediateResponseDelivery;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.TimeUnit;
-
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 import static org.mockito.MockitoAnnotations.initMocks;
 
 
 /**
- * Integration tests for {@link RequestQueue}, that verify its behavior in conjunction with real dispatcher, queues and
- * Requests. Network is mocked out
+ * Integration tests for {@link RequestQueue} that verify its behavior in conjunction with real
+ * dispatcher, queues and Requests.
+ *
+ * <p>The Network is mocked out.
  */
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = {ShadowSystemClock.class})
@@ -52,6 +53,8 @@ public class RequestQueueIntegrationTest {
 
     private ResponseDelivery mDelivery;
     @Mock private Network mMockNetwork;
+    @Mock private RequestFinishedListener<byte[]> mMockListener;
+    @Mock private RequestFinishedListener<byte[]> mMockListener2;
 
     @Before public void setUp() throws Exception {
         mDelivery = new ImmediateResponseDelivery();
@@ -59,9 +62,10 @@ public class RequestQueueIntegrationTest {
     }
 
     @Test public void add_requestProcessedInCorrectOrder() throws Exception {
-        // Enqueue 2 requests with different cache keys, and different priorities. The second, higher priority request
-        // takes 20ms.
-        // Assert that first request is only handled after the first one has been parsed and delivered.
+        // Enqueue 2 requests with different cache keys, and different priorities. The second,
+        // higher priority request takes 20ms.
+        // Assert that the first request is only handled after the first one has been parsed and
+        // delivered.
         MockRequest lowerPriorityReq = new MockRequest();
         MockRequest higherPriorityReq = new MockRequest();
         lowerPriorityReq.setCacheKey("1");
@@ -69,7 +73,6 @@ public class RequestQueueIntegrationTest {
         lowerPriorityReq.setPriority(Priority.LOW);
         higherPriorityReq.setPriority(Priority.HIGH);
 
-        RequestFinishedListener listener = mock(RequestFinishedListener.class);
         Answer<NetworkResponse> delayAnswer = new Answer<NetworkResponse>() {
             @Override
             public NetworkResponse answer(InvocationOnMock invocationOnMock) throws Throwable {
@@ -77,37 +80,31 @@ public class RequestQueueIntegrationTest {
                 return mock(NetworkResponse.class);
             }
         };
-        //delay only for higher request
+        // delay only for higher request
         when(mMockNetwork.performRequest(higherPriorityReq)).thenAnswer(delayAnswer);
         when(mMockNetwork.performRequest(lowerPriorityReq)).thenReturn(mock(NetworkResponse.class));
 
         RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);
-        queue.addRequestFinishedListener(listener);
+        queue.addRequestFinishedListener(mMockListener);
         queue.add(lowerPriorityReq);
         queue.add(higherPriorityReq);
         queue.start();
 
-        // you cannot do strict order verification in combination with timeouts with mockito 1.9.5 :(
-        // as an alternative, first verify no requests have finished, while higherPriorityReq should be processing
-        verifyNoMoreInteractions(listener);
+        InOrder inOrder = inOrder(mMockListener);
         // verify higherPriorityReq goes through first
-        verify(listener, timeout(100)).onRequestFinished(higherPriorityReq);
+        inOrder.verify(mMockListener, timeout(10000)).onRequestFinished(higherPriorityReq);
         // verify lowerPriorityReq goes last
-        verify(listener, timeout(10)).onRequestFinished(lowerPriorityReq);
+        inOrder.verify(mMockListener, timeout(10000)).onRequestFinished(lowerPriorityReq);
+
         queue.stop();
     }
 
-    /**
-     * Asserts that requests with same cache key are processed in order.
-     *
-     * Needs to be an integration test because relies on complex interations between various queues
-     */
+    /** Asserts that requests with same cache key are processed in order. */
     @Test public void add_dedupeByCacheKey() throws Exception {
         // Enqueue 2 requests with the same cache key. The first request takes 20ms. Assert that the
         // second request is only handled after the first one has been parsed and delivered.
-        Request req1 = new MockRequest();
-        Request req2 = new MockRequest();
-        RequestFinishedListener listener = mock(RequestFinishedListener.class);
+        MockRequest req1 = new MockRequest();
+        MockRequest req2 = new MockRequest();
         Answer<NetworkResponse> delayAnswer = new Answer<NetworkResponse>() {
             @Override
             public NetworkResponse answer(InvocationOnMock invocationOnMock) throws Throwable {
@@ -120,27 +117,23 @@ public class RequestQueueIntegrationTest {
         when(mMockNetwork.performRequest(req2)).thenReturn(mock(NetworkResponse.class));
 
         RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 3, mDelivery);
-        queue.addRequestFinishedListener(listener);
+        queue.addRequestFinishedListener(mMockListener);
         queue.add(req1);
         queue.add(req2);
         queue.start();
 
-        // you cannot do strict order verification with mockito 1.9.5 :(
-        // as an alternative, first verify no requests have finished, then verify req1 goes through
-        verifyNoMoreInteractions(listener);
-        verify(listener, timeout(100)).onRequestFinished(req1);
-        verify(listener, timeout(10)).onRequestFinished(req2);
+        InOrder inOrder = inOrder(mMockListener);
+        // verify req1 goes through first
+        inOrder.verify(mMockListener, timeout(10000)).onRequestFinished(req1);
+        // verify req2 goes last
+        inOrder.verify(mMockListener, timeout(10000)).onRequestFinished(req2);
+
         queue.stop();
     }
 
-    /**
-     * Verify RequestFinishedListeners are informed when requests are canceled
-     *
-     * Needs to be an integration test because relies on Request -> dispatcher -> RequestQueue interaction
-     */
+    /** Verify RequestFinishedListeners are informed when requests are canceled.  */
     @Test public void add_requestFinishedListenerCanceled() throws Exception {
-        RequestFinishedListener listener = mock(RequestFinishedListener.class);
-        Request request = new MockRequest();
+        MockRequest request = new MockRequest();
         Answer<NetworkResponse> delayAnswer = new Answer<NetworkResponse>() {
             @Override
             public NetworkResponse answer(InvocationOnMock invocationOnMock) throws Throwable {
@@ -152,56 +145,43 @@ public class RequestQueueIntegrationTest {
 
         when(mMockNetwork.performRequest(request)).thenAnswer(delayAnswer);
 
-        queue.addRequestFinishedListener(listener);
+        queue.addRequestFinishedListener(mMockListener);
         queue.start();
         queue.add(request);
 
         request.cancel();
-        verify(listener, timeout(100)).onRequestFinished(request);
+        verify(mMockListener, timeout(10000)).onRequestFinished(request);
         queue.stop();
     }
 
-    /**
-     * Verify RequestFinishedListeners are informed when requests are successfully delivered
-     *
-     * Needs to be an integration test because relies on Request -> dispatcher -> RequestQueue interaction
-     */
+    /** Verify RequestFinishedListeners are informed when requests are successfully delivered. */
     @Test public void add_requestFinishedListenerSuccess() throws Exception {
-        NetworkResponse response = mock(NetworkResponse.class);
-        Request request = new MockRequest();
-        RequestFinishedListener listener = mock(RequestFinishedListener.class);
-        RequestFinishedListener listener2 = mock(RequestFinishedListener.class);
+        MockRequest request = new MockRequest();
         RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);
 
-        queue.addRequestFinishedListener(listener);
-        queue.addRequestFinishedListener(listener2);
+        queue.addRequestFinishedListener(mMockListener);
+        queue.addRequestFinishedListener(mMockListener2);
         queue.start();
         queue.add(request);
 
-        verify(listener, timeout(100)).onRequestFinished(request);
-        verify(listener2, timeout(100)).onRequestFinished(request);
+        verify(mMockListener, timeout(10000)).onRequestFinished(request);
+        verify(mMockListener2, timeout(10000)).onRequestFinished(request);
 
         queue.stop();
     }
 
-    /**
-     * Verify RequestFinishedListeners are informed when request errors
-     *
-     * Needs to be an integration test because relies on Request -> dispatcher -> RequestQueue interaction
-     */
+    /** Verify RequestFinishedListeners are informed when request errors. */
     @Test public void add_requestFinishedListenerError() throws Exception {
-        RequestFinishedListener listener = mock(RequestFinishedListener.class);
-        Request request = new MockRequest();
+        MockRequest request = new MockRequest();
         RequestQueue queue = new RequestQueue(new NoCache(), mMockNetwork, 1, mDelivery);
 
         when(mMockNetwork.performRequest(request)).thenThrow(new VolleyError());
 
-        queue.addRequestFinishedListener(listener);
+        queue.addRequestFinishedListener(mMockListener);
         queue.start();
         queue.add(request);
 
-        verify(listener, timeout(100)).onRequestFinished(request);
+        verify(mMockListener, timeout(10000)).onRequestFinished(request);
         queue.stop();
     }
-
 }
diff --git a/src/test/java/com/android/volley/mock/MockHttpClient.java b/src/test/java/com/android/volley/mock/MockHttpClient.java
deleted file mode 100644
index c2a36bc..0000000
--- a/src/test/java/com/android/volley/mock/MockHttpClient.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * 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 com.android.volley.mock;
-
-import org.apache.http.HttpEntity;
-import org.apache.http.HttpHost;
-import org.apache.http.HttpRequest;
-import org.apache.http.HttpResponse;
-import org.apache.http.HttpStatus;
-import org.apache.http.ProtocolVersion;
-import org.apache.http.StatusLine;
-import org.apache.http.client.HttpClient;
-import org.apache.http.client.ResponseHandler;
-import org.apache.http.client.methods.HttpUriRequest;
-import org.apache.http.conn.ClientConnectionManager;
-import org.apache.http.message.BasicHttpResponse;
-import org.apache.http.message.BasicStatusLine;
-import org.apache.http.params.HttpParams;
-import org.apache.http.protocol.HttpContext;
-
-
-public class MockHttpClient implements HttpClient {
-    private int mStatusCode = HttpStatus.SC_OK;
-    private HttpEntity mResponseEntity = null;
-
-    public void setResponseData(HttpEntity entity) {
-        mStatusCode = HttpStatus.SC_OK;
-        mResponseEntity = entity;
-    }
-
-    public void setErrorCode(int statusCode) {
-        if (statusCode == HttpStatus.SC_OK) {
-            throw new IllegalArgumentException("statusCode cannot be 200 for an error");
-        }
-        mStatusCode = statusCode;
-    }
-
-    public HttpUriRequest requestExecuted = null;
-
-    // This is the only one we actually use.
-    @Override
-    public HttpResponse execute(HttpUriRequest request, HttpContext context) {
-        requestExecuted = request;
-        StatusLine statusLine = new BasicStatusLine(
-                new ProtocolVersion("HTTP", 1, 1), mStatusCode, "");
-        HttpResponse response = new BasicHttpResponse(statusLine);
-        response.setEntity(mResponseEntity);
-
-        return response;
-    }
-
-
-    // Unimplemented methods ahoy
-
-    @Override
-    public HttpResponse execute(HttpUriRequest request) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public HttpResponse execute(HttpHost target, HttpRequest request) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public <T> T execute(HttpUriRequest arg0, ResponseHandler<? extends T> arg1) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public HttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public <T> T execute(HttpUriRequest arg0, ResponseHandler<? extends T> arg1, HttpContext arg2) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public <T> T execute(HttpHost arg0, HttpRequest arg1, ResponseHandler<? extends T> arg2) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public <T> T execute(HttpHost arg0, HttpRequest arg1, ResponseHandler<? extends T> arg2,
-            HttpContext arg3) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public ClientConnectionManager getConnectionManager() {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public HttpParams getParams() {
-        throw new UnsupportedOperationException();
-    }
-}
diff --git a/src/test/java/com/android/volley/mock/MockHttpStack.java b/src/test/java/com/android/volley/mock/MockHttpStack.java
index 91872d3..56b29f1 100644
--- a/src/test/java/com/android/volley/mock/MockHttpStack.java
+++ b/src/test/java/com/android/volley/mock/MockHttpStack.java
@@ -18,15 +18,14 @@ package com.android.volley.mock;
 
 import com.android.volley.AuthFailureError;
 import com.android.volley.Request;
-import com.android.volley.toolbox.HttpStack;
-
-import org.apache.http.HttpResponse;
+import com.android.volley.toolbox.BaseHttpStack;
+import com.android.volley.toolbox.HttpResponse;
 
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 
-public class MockHttpStack implements HttpStack {
+public class MockHttpStack extends BaseHttpStack {
 
     private HttpResponse mResponseToReturn;
 
@@ -59,13 +58,13 @@ public class MockHttpStack implements HttpStack {
     }
 
     @Override
-    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
+    public HttpResponse executeRequest(Request<?> request, Map<String, String> additionalHeaders)
             throws IOException, AuthFailureError {
         if (mExceptionToThrow != null) {
             throw mExceptionToThrow;
         }
         mLastUrl = request.getUrl();
-        mLastHeaders = new HashMap<String, String>();
+        mLastHeaders = new HashMap<>();
         if (request.getHeaders() != null) {
             mLastHeaders.putAll(request.getHeaders());
         }
diff --git a/src/test/java/com/android/volley/mock/MockResponseDelivery.java b/src/test/java/com/android/volley/mock/MockResponseDelivery.java
index 4dbfd5c..e923c1a 100644
--- a/src/test/java/com/android/volley/mock/MockResponseDelivery.java
+++ b/src/test/java/com/android/volley/mock/MockResponseDelivery.java
@@ -25,6 +25,7 @@ public class MockResponseDelivery implements ResponseDelivery {
 
     public boolean postResponse_called = false;
     public boolean postError_called = false;
+    public long postResponse_calledNtimes = 0;
 
     public boolean wasEitherResponseCalled() {
         return postResponse_called || postError_called;
@@ -34,12 +35,14 @@ public class MockResponseDelivery implements ResponseDelivery {
     @Override
     public void postResponse(Request<?> request, Response<?> response) {
         postResponse_called = true;
+        postResponse_calledNtimes++;
         responsePosted = response;
     }
 
     @Override
     public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
         postResponse_called = true;
+        postResponse_calledNtimes++;
         responsePosted = response;
         runnable.run();
     }
diff --git a/src/test/java/com/android/volley/toolbox/AdaptedHttpStackTest.java b/src/test/java/com/android/volley/toolbox/AdaptedHttpStackTest.java
new file mode 100644
index 0000000..615687d
--- /dev/null
+++ b/src/test/java/com/android/volley/toolbox/AdaptedHttpStackTest.java
@@ -0,0 +1,135 @@
+package com.android.volley.toolbox;
+
+import android.util.Pair;
+
+import com.android.volley.Header;
+import com.android.volley.Request;
+import com.android.volley.mock.TestRequest;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.StatusLine;
+import org.apache.http.conn.ConnectTimeoutException;
+import org.apache.http.message.BasicHeader;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.when;
+
+@RunWith(RobolectricTestRunner.class)
+public class AdaptedHttpStackTest {
+    private static final Request<?> REQUEST = new TestRequest.Get();
+    private static final Map<String, String> ADDITIONAL_HEADERS = Collections.emptyMap();
+
+    @Mock
+    private HttpStack mHttpStack;
+    @Mock
+    private HttpResponse mHttpResponse;
+    @Mock
+    private StatusLine mStatusLine;
+    @Mock
+    private HttpEntity mHttpEntity;
+    @Mock
+    private InputStream mContent;
+
+    private AdaptedHttpStack mAdaptedHttpStack;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mAdaptedHttpStack = new AdaptedHttpStack(mHttpStack);
+        when(mHttpResponse.getStatusLine()).thenReturn(mStatusLine);
+    }
+
+    @Test(expected = SocketTimeoutException.class)
+    public void requestTimeout() throws Exception {
+        when(mHttpStack.performRequest(REQUEST, ADDITIONAL_HEADERS))
+                .thenThrow(new ConnectTimeoutException());
+
+        mAdaptedHttpStack.executeRequest(REQUEST, ADDITIONAL_HEADERS);
+    }
+
+    @Test
+    public void emptyResponse() throws Exception {
+        when(mHttpStack.performRequest(REQUEST, ADDITIONAL_HEADERS)).thenReturn(mHttpResponse);
+        when(mStatusLine.getStatusCode()).thenReturn(12345);
+        when(mHttpResponse.getAllHeaders()).thenReturn(new org.apache.http.Header[0]);
+
+        com.android.volley.toolbox.HttpResponse response =
+                mAdaptedHttpStack.executeRequest(REQUEST, ADDITIONAL_HEADERS);
+
+        assertEquals(12345, response.getStatusCode());
+        assertEquals(Collections.emptyList(), response.getHeaders());
+        assertNull(response.getContent());
+    }
+
+    @Test
+    public void nonEmptyResponse() throws Exception {
+        when(mHttpStack.performRequest(REQUEST, ADDITIONAL_HEADERS)).thenReturn(mHttpResponse);
+        when(mStatusLine.getStatusCode()).thenReturn(12345);
+        when(mHttpResponse.getAllHeaders()).thenReturn(new org.apache.http.Header[0]);
+        when(mHttpResponse.getEntity()).thenReturn(mHttpEntity);
+        when(mHttpEntity.getContentLength()).thenReturn((long) Integer.MAX_VALUE);
+        when(mHttpEntity.getContent()).thenReturn(mContent);
+
+        com.android.volley.toolbox.HttpResponse response =
+                mAdaptedHttpStack.executeRequest(REQUEST, ADDITIONAL_HEADERS);
+
+        assertEquals(12345, response.getStatusCode());
+        assertEquals(Collections.emptyList(), response.getHeaders());
+        assertEquals(Integer.MAX_VALUE, response.getContentLength());
+        assertSame(mContent, response.getContent());
+    }
+
+    @Test(expected = IOException.class)
+    public void responseTooBig() throws Exception {
+        when(mHttpStack.performRequest(REQUEST, ADDITIONAL_HEADERS)).thenReturn(mHttpResponse);
+        when(mStatusLine.getStatusCode()).thenReturn(12345);
+        when(mHttpResponse.getAllHeaders()).thenReturn(new org.apache.http.Header[0]);
+        when(mHttpResponse.getEntity()).thenReturn(mHttpEntity);
+        when(mHttpEntity.getContentLength()).thenReturn(Integer.MAX_VALUE + 1L);
+        when(mHttpEntity.getContent()).thenReturn(mContent);
+
+        mAdaptedHttpStack.executeRequest(REQUEST, ADDITIONAL_HEADERS);
+    }
+
+    @Test
+    public void responseWithHeaders() throws Exception {
+        when(mHttpStack.performRequest(REQUEST, ADDITIONAL_HEADERS)).thenReturn(mHttpResponse);
+        when(mStatusLine.getStatusCode()).thenReturn(12345);
+        when(mHttpResponse.getAllHeaders()).thenReturn(new org.apache.http.Header[] {
+                new BasicHeader("header1", "value1_B"),
+                new BasicHeader("header3", "value3"),
+                new BasicHeader("HEADER2", "value2"),
+                new BasicHeader("header1", "value1_A")
+        });
+
+        com.android.volley.toolbox.HttpResponse response =
+                mAdaptedHttpStack.executeRequest(REQUEST, ADDITIONAL_HEADERS);
+
+        assertEquals(12345, response.getStatusCode());
+        assertNull(response.getContent());
+
+        List<Header> expectedHeaders = new ArrayList<>();
+        expectedHeaders.add(new Header("header1", "value1_B"));
+        expectedHeaders.add(new Header("header3", "value3"));
+        expectedHeaders.add(new Header("HEADER2", "value2"));
+        expectedHeaders.add(new Header("header1", "value1_A"));
+        assertEquals(expectedHeaders, response.getHeaders());
+    }
+}
diff --git a/src/test/java/com/android/volley/toolbox/BaseHttpStackTest.java b/src/test/java/com/android/volley/toolbox/BaseHttpStackTest.java
new file mode 100644
index 0000000..3ae145c
--- /dev/null
+++ b/src/test/java/com/android/volley/toolbox/BaseHttpStackTest.java
@@ -0,0 +1,108 @@
+package com.android.volley.toolbox;
+
+import com.android.volley.AuthFailureError;
+import com.android.volley.Header;
+import com.android.volley.Request;
+import com.android.volley.mock.TestRequest;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RobolectricTestRunner;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
+@RunWith(RobolectricTestRunner.class)
+public class BaseHttpStackTest {
+    private static final Request<?> REQUEST = new TestRequest.Get();
+    private static final Map<String, String> ADDITIONAL_HEADERS = Collections.emptyMap();
+
+    @Mock
+    private InputStream mContent;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void legacyRequestWithoutBody() throws Exception {
+        BaseHttpStack stack = new BaseHttpStack() {
+            @Override
+            public HttpResponse executeRequest(
+                    Request<?> request, Map<String, String> additionalHeaders)
+                    throws IOException, AuthFailureError {
+                assertSame(REQUEST, request);
+                assertSame(ADDITIONAL_HEADERS, additionalHeaders);
+                return new HttpResponse(12345, Collections.<Header>emptyList());
+            }
+        };
+        org.apache.http.HttpResponse resp = stack.performRequest(REQUEST, ADDITIONAL_HEADERS);
+        assertEquals(12345, resp.getStatusLine().getStatusCode());
+        assertEquals(0, resp.getAllHeaders().length);
+        assertNull(resp.getEntity());
+    }
+
+    @Test
+    public void legacyResponseWithBody() throws Exception {
+        BaseHttpStack stack = new BaseHttpStack() {
+            @Override
+            public HttpResponse executeRequest(
+                    Request<?> request, Map<String, String> additionalHeaders)
+                    throws IOException, AuthFailureError {
+                assertSame(REQUEST, request);
+                assertSame(ADDITIONAL_HEADERS, additionalHeaders);
+                return new HttpResponse(
+                        12345,
+                        Collections.<Header>emptyList(),
+                        555,
+                        mContent);
+            }
+        };
+        org.apache.http.HttpResponse resp = stack.performRequest(REQUEST, ADDITIONAL_HEADERS);
+        assertEquals(12345, resp.getStatusLine().getStatusCode());
+        assertEquals(0, resp.getAllHeaders().length);
+        assertEquals(555L, resp.getEntity().getContentLength());
+        assertSame(mContent, resp.getEntity().getContent());
+    }
+
+    @Test
+    public void legacyResponseHeaders() throws Exception {
+        BaseHttpStack stack = new BaseHttpStack() {
+            @Override
+            public HttpResponse executeRequest(
+                    Request<?> request, Map<String, String> additionalHeaders)
+                    throws IOException, AuthFailureError {
+                assertSame(REQUEST, request);
+                assertSame(ADDITIONAL_HEADERS, additionalHeaders);
+                List<Header> headers = new ArrayList<>();
+                headers.add(new Header("HeaderA", "ValueA"));
+                headers.add(new Header("HeaderB", "ValueB_1"));
+                headers.add(new Header("HeaderB", "ValueB_2"));
+                return new HttpResponse(12345, headers);
+            }
+        };
+        org.apache.http.HttpResponse resp = stack.performRequest(REQUEST, ADDITIONAL_HEADERS);
+        assertEquals(12345, resp.getStatusLine().getStatusCode());
+        assertEquals(3, resp.getAllHeaders().length);
+        assertEquals("HeaderA", resp.getAllHeaders()[0].getName());
+        assertEquals("ValueA", resp.getAllHeaders()[0].getValue());
+        assertEquals("HeaderB", resp.getAllHeaders()[1].getName());
+        assertEquals("ValueB_1", resp.getAllHeaders()[1].getValue());
+        assertEquals("HeaderB", resp.getAllHeaders()[2].getName());
+        assertEquals("ValueB_2", resp.getAllHeaders()[2].getValue());
+        assertNull(resp.getEntity());
+    }
+}
diff --git a/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java b/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java
index c01d9b0..7f0d5e2 100644
--- a/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java
+++ b/src/test/java/com/android/volley/toolbox/BasicNetworkTest.java
@@ -17,6 +17,8 @@
 package com.android.volley.toolbox;
 
 import com.android.volley.AuthFailureError;
+import com.android.volley.Cache.Entry;
+import com.android.volley.Header;
 import com.android.volley.NetworkResponse;
 import com.android.volley.Request;
 import com.android.volley.Response;
@@ -26,23 +28,31 @@ import com.android.volley.TimeoutError;
 import com.android.volley.VolleyError;
 import com.android.volley.mock.MockHttpStack;
 
-import org.apache.http.ProtocolVersion;
-import org.apache.http.conn.ConnectTimeoutException;
-import org.apache.http.entity.StringEntity;
-import org.apache.http.message.BasicHttpResponse;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.robolectric.RobolectricTestRunner;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
 import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
 import static org.mockito.MockitoAnnotations.initMocks;
 
 @RunWith(RobolectricTestRunner.class)
@@ -50,7 +60,6 @@ public class BasicNetworkTest {
 
     @Mock private Request<String> mMockRequest;
     @Mock private RetryPolicy mMockRetryPolicy;
-    private BasicNetwork mNetwork;
 
     @Before public void setUp() throws Exception {
         initMocks(this);
@@ -58,36 +67,98 @@ public class BasicNetworkTest {
 
     @Test public void headersAndPostParams() throws Exception {
         MockHttpStack mockHttpStack = new MockHttpStack();
-        BasicHttpResponse fakeResponse = new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1),
-                200, "OK");
-        fakeResponse.setEntity(new StringEntity("foobar"));
+        InputStream responseStream =
+                new ByteArrayInputStream("foobar".getBytes());
+        HttpResponse fakeResponse =
+                new HttpResponse(200, Collections.<Header>emptyList(), 6, responseStream);
         mockHttpStack.setResponseToReturn(fakeResponse);
         BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
         Request<String> request = buildRequest();
+        Entry entry = new Entry();
+        entry.etag = "foobar";
+        entry.lastModified = 1503102002000L;
+        request.setCacheEntry(entry);
         httpNetwork.performRequest(request);
         assertEquals("foo", mockHttpStack.getLastHeaders().get("requestheader"));
+        assertEquals("foobar", mockHttpStack.getLastHeaders().get("If-None-Match"));
+        assertEquals("Sat, 19 Aug 2017 00:20:02 GMT",
+                mockHttpStack.getLastHeaders().get("If-Modified-Since"));
         assertEquals("requestpost=foo&", new String(mockHttpStack.getLastPostBody()));
     }
 
-    @Test public void socketTimeout() throws Exception {
+    @Test public void notModified() throws Exception {
         MockHttpStack mockHttpStack = new MockHttpStack();
-        mockHttpStack.setExceptionToThrow(new SocketTimeoutException());
+        List<Header> headers = new ArrayList<>();
+        headers.add(new Header("ServerKeyA", "ServerValueA"));
+        headers.add(new Header("ServerKeyB", "ServerValueB"));
+        headers.add(new Header("SharedKey", "ServerValueShared"));
+        headers.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+        headers.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+        HttpResponse fakeResponse =
+                new HttpResponse(HttpURLConnection.HTTP_NOT_MODIFIED, headers);
+        mockHttpStack.setResponseToReturn(fakeResponse);
         BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
         Request<String> request = buildRequest();
-        request.setRetryPolicy(mMockRetryPolicy);
-        doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
-        try {
-            httpNetwork.performRequest(request);
-        } catch (VolleyError e) {
-            // expected
-        }
-        // should retry socket timeouts
-        verify(mMockRetryPolicy).retry(any(TimeoutError.class));
+        Entry entry = new Entry();
+        entry.allResponseHeaders = new ArrayList<>();
+        entry.allResponseHeaders.add(new Header("CachedKeyA", "CachedValueA"));
+        entry.allResponseHeaders.add(new Header("CachedKeyB", "CachedValueB"));
+        entry.allResponseHeaders.add(new Header("SharedKey", "CachedValueShared"));
+        entry.allResponseHeaders.add(new Header("SHAREDCASEINSENSITIVEKEY", "CachedValueShared1"));
+        entry.allResponseHeaders.add(new Header("shAREDcaSEinSENSITIVEkeY", "CachedValueShared2"));
+        request.setCacheEntry(entry);
+        NetworkResponse response = httpNetwork.performRequest(request);
+        List<Header> expectedHeaders = new ArrayList<>();
+        // Should have all server headers + cache headers that didn't show up in server response.
+        expectedHeaders.add(new Header("ServerKeyA", "ServerValueA"));
+        expectedHeaders.add(new Header("ServerKeyB", "ServerValueB"));
+        expectedHeaders.add(new Header("SharedKey", "ServerValueShared"));
+        expectedHeaders.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+        expectedHeaders.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+        expectedHeaders.add(new Header("CachedKeyA", "CachedValueA"));
+        expectedHeaders.add(new Header("CachedKeyB", "CachedValueB"));
+        assertThat(expectedHeaders, containsInAnyOrder(
+                response.allHeaders.toArray(new Header[response.allHeaders.size()])));
+    }
+
+    @Test public void notModified_legacyCache() throws Exception {
+        MockHttpStack mockHttpStack = new MockHttpStack();
+        List<Header> headers = new ArrayList<>();
+        headers.add(new Header("ServerKeyA", "ServerValueA"));
+        headers.add(new Header("ServerKeyB", "ServerValueB"));
+        headers.add(new Header("SharedKey", "ServerValueShared"));
+        headers.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+        headers.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+        HttpResponse fakeResponse =
+                new HttpResponse(HttpURLConnection.HTTP_NOT_MODIFIED, headers);
+        mockHttpStack.setResponseToReturn(fakeResponse);
+        BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
+        Request<String> request = buildRequest();
+        Entry entry = new Entry();
+        entry.responseHeaders = new HashMap<>();
+        entry.responseHeaders.put("CachedKeyA", "CachedValueA");
+        entry.responseHeaders.put("CachedKeyB", "CachedValueB");
+        entry.responseHeaders.put("SharedKey", "CachedValueShared");
+        entry.responseHeaders.put("SHAREDCASEINSENSITIVEKEY", "CachedValueShared1");
+        entry.responseHeaders.put("shAREDcaSEinSENSITIVEkeY", "CachedValueShared2");
+        request.setCacheEntry(entry);
+        NetworkResponse response = httpNetwork.performRequest(request);
+        List<Header> expectedHeaders = new ArrayList<>();
+        // Should have all server headers + cache headers that didn't show up in server response.
+        expectedHeaders.add(new Header("ServerKeyA", "ServerValueA"));
+        expectedHeaders.add(new Header("ServerKeyB", "ServerValueB"));
+        expectedHeaders.add(new Header("SharedKey", "ServerValueShared"));
+        expectedHeaders.add(new Header("sharedcaseinsensitivekey", "ServerValueShared1"));
+        expectedHeaders.add(new Header("SharedCaseInsensitiveKey", "ServerValueShared2"));
+        expectedHeaders.add(new Header("CachedKeyA", "CachedValueA"));
+        expectedHeaders.add(new Header("CachedKeyB", "CachedValueB"));
+        assertThat(expectedHeaders, containsInAnyOrder(
+                response.allHeaders.toArray(new Header[response.allHeaders.size()])));
     }
 
-    @Test public void connectTimeout() throws Exception {
+    @Test public void socketTimeout() throws Exception {
         MockHttpStack mockHttpStack = new MockHttpStack();
-        mockHttpStack.setExceptionToThrow(new ConnectTimeoutException());
+        mockHttpStack.setExceptionToThrow(new SocketTimeoutException());
         BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
         Request<String> request = buildRequest();
         request.setRetryPolicy(mMockRetryPolicy);
@@ -97,7 +168,7 @@ public class BasicNetworkTest {
         } catch (VolleyError e) {
             // expected
         }
-        // should retry connection timeouts
+        // should retry socket timeouts
         verify(mMockRetryPolicy).retry(any(TimeoutError.class));
     }
 
@@ -119,8 +190,7 @@ public class BasicNetworkTest {
 
     @Test public void unauthorized() throws Exception {
         MockHttpStack mockHttpStack = new MockHttpStack();
-        BasicHttpResponse fakeResponse = new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1),
-                401, "Unauthorized");
+        HttpResponse fakeResponse = new HttpResponse(401, Collections.<Header>emptyList());
         mockHttpStack.setResponseToReturn(fakeResponse);
         BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
         Request<String> request = buildRequest();
@@ -137,8 +207,7 @@ public class BasicNetworkTest {
 
     @Test public void forbidden() throws Exception {
         MockHttpStack mockHttpStack = new MockHttpStack();
-        BasicHttpResponse fakeResponse = new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1),
-                403, "Forbidden");
+        HttpResponse fakeResponse = new HttpResponse(403, Collections.<Header>emptyList());
         mockHttpStack.setResponseToReturn(fakeResponse);
         BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
         Request<String> request = buildRequest();
@@ -156,8 +225,7 @@ public class BasicNetworkTest {
     @Test public void redirect() throws Exception {
         for (int i = 300; i <= 399; i++) {
             MockHttpStack mockHttpStack = new MockHttpStack();
-            BasicHttpResponse fakeResponse =
-                    new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1), i, "");
+            HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
             mockHttpStack.setResponseToReturn(fakeResponse);
             BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
             Request<String> request = buildRequest();
@@ -181,8 +249,7 @@ public class BasicNetworkTest {
                 continue;
             }
             MockHttpStack mockHttpStack = new MockHttpStack();
-            BasicHttpResponse fakeResponse =
-                    new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1), i, "");
+            HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
             mockHttpStack.setResponseToReturn(fakeResponse);
             BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
             Request<String> request = buildRequest();
@@ -202,8 +269,7 @@ public class BasicNetworkTest {
     @Test public void serverError_enableRetries() throws Exception {
         for (int i = 500; i <= 599; i++) {
             MockHttpStack mockHttpStack = new MockHttpStack();
-            BasicHttpResponse fakeResponse =
-                    new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1), i, "");
+            HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
             mockHttpStack.setResponseToReturn(fakeResponse);
             BasicNetwork httpNetwork =
                     new BasicNetwork(mockHttpStack, new ByteArrayPool(4096));
@@ -225,8 +291,7 @@ public class BasicNetworkTest {
     @Test public void serverError_disableRetries() throws Exception {
         for (int i = 500; i <= 599; i++) {
             MockHttpStack mockHttpStack = new MockHttpStack();
-            BasicHttpResponse fakeResponse =
-                    new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1), i, "");
+            HttpResponse fakeResponse = new HttpResponse(i, Collections.<Header>emptyList());
             mockHttpStack.setResponseToReturn(fakeResponse);
             BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
             Request<String> request = buildRequest();
diff --git a/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java b/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java
index 3d8d1f1..04c071e 100644
--- a/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java
+++ b/src/test/java/com/android/volley/toolbox/DiskBasedCacheTest.java
@@ -17,6 +17,7 @@
 package com.android.volley.toolbox;
 
 import com.android.volley.Cache;
+import com.android.volley.Header;
 import com.android.volley.toolbox.DiskBasedCache.CacheHeader;
 import com.android.volley.toolbox.DiskBasedCache.CountingInputStream;
 
@@ -38,7 +39,9 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Random;
 
@@ -428,28 +431,33 @@ public class DiskBasedCacheTest {
         assertEquals(DiskBasedCache.readString(cis), "ファイカス");
     }
 
-    @Test public void serializeMap() throws Exception {
+    @Test public void serializeHeaders() throws Exception {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        Map<String, String> empty = new HashMap<>();
-        DiskBasedCache.writeStringStringMap(empty, baos);
-        DiskBasedCache.writeStringStringMap(null, baos);
-        Map<String, String> twoThings = new HashMap<>();
-        twoThings.put("first", "thing");
-        twoThings.put("second", "item");
-        DiskBasedCache.writeStringStringMap(twoThings, baos);
-        Map<String, String> emptyKey = new HashMap<>();
-        emptyKey.put("", "value");
-        DiskBasedCache.writeStringStringMap(emptyKey, baos);
-        Map<String, String> emptyValue = new HashMap<>();
-        emptyValue.put("key", "");
-        DiskBasedCache.writeStringStringMap(emptyValue, baos);
+        List<Header> empty = new ArrayList<>();
+        DiskBasedCache.writeHeaderList(empty, baos);
+        DiskBasedCache.writeHeaderList(null, baos);
+        List<Header> twoThings = new ArrayList<>();
+        twoThings.add(new Header("first", "thing"));
+        twoThings.add(new Header("second", "item"));
+        DiskBasedCache.writeHeaderList(twoThings, baos);
+        List<Header> emptyKey = new ArrayList<>();
+        emptyKey.add(new Header("", "value"));
+        DiskBasedCache.writeHeaderList(emptyKey, baos);
+        List<Header> emptyValue = new ArrayList<>();
+        emptyValue.add(new Header("key", ""));
+        DiskBasedCache.writeHeaderList(emptyValue, baos);
+        List<Header> sameKeys = new ArrayList<>();
+        sameKeys.add(new Header("key", "value"));
+        sameKeys.add(new Header("key", "value2"));
+        DiskBasedCache.writeHeaderList(sameKeys, baos);
         CountingInputStream cis =
                 new CountingInputStream(new ByteArrayInputStream(baos.toByteArray()), baos.size());
-        assertEquals(DiskBasedCache.readStringStringMap(cis), empty);
-        assertEquals(DiskBasedCache.readStringStringMap(cis), empty); // null reads back empty
-        assertEquals(DiskBasedCache.readStringStringMap(cis), twoThings);
-        assertEquals(DiskBasedCache.readStringStringMap(cis), emptyKey);
-        assertEquals(DiskBasedCache.readStringStringMap(cis), emptyValue);
+        assertEquals(DiskBasedCache.readHeaderList(cis), empty);
+        assertEquals(DiskBasedCache.readHeaderList(cis), empty); // null reads back empty
+        assertEquals(DiskBasedCache.readHeaderList(cis), twoThings);
+        assertEquals(DiskBasedCache.readHeaderList(cis), emptyKey);
+        assertEquals(DiskBasedCache.readHeaderList(cis), emptyValue);
+        assertEquals(DiskBasedCache.readHeaderList(cis), sameKeys);
     }
 
     @Test
diff --git a/src/test/java/com/android/volley/toolbox/HttpHeaderParserTest.java b/src/test/java/com/android/volley/toolbox/HttpHeaderParserTest.java
index fd8cf51..9ccac05 100644
--- a/src/test/java/com/android/volley/toolbox/HttpHeaderParserTest.java
+++ b/src/test/java/com/android/volley/toolbox/HttpHeaderParserTest.java
@@ -17,10 +17,9 @@
 package com.android.volley.toolbox;
 
 import com.android.volley.Cache;
+import com.android.volley.Header;
 import com.android.volley.NetworkResponse;
 
-import org.apache.http.Header;
-import org.apache.http.message.BasicHeader;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -28,8 +27,10 @@ import org.robolectric.RobolectricTestRunner;
 
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 
@@ -269,24 +270,23 @@ public class HttpHeaderParserTest {
     }
 
     @Test public void parseCaseInsensitive() {
-
         long now = System.currentTimeMillis();
 
-        Header[] headersArray = new Header[5];
-        headersArray[0] = new BasicHeader("eTAG", "Yow!");
-        headersArray[1] = new BasicHeader("DATE", rfc1123Date(now));
-        headersArray[2] = new BasicHeader("expires", rfc1123Date(now + ONE_HOUR_MILLIS));
-        headersArray[3] = new BasicHeader("cache-control", "public, max-age=86400");
-        headersArray[4] = new BasicHeader("content-type", "text/plain");
+        List<Header> headers = new ArrayList<>();
+        headers.add(new Header("eTAG", "Yow!"));
+        headers.add(new Header("DATE", rfc1123Date(now)));
+        headers.add(new Header("expires", rfc1123Date(now + ONE_HOUR_MILLIS)));
+        headers.add(new Header("cache-control", "public, max-age=86400"));
+        headers.add(new Header("content-type", "text/plain"));
 
-        Map<String, String> headers = BasicNetwork.convertHeaders(headersArray);
-        NetworkResponse response = new NetworkResponse(0, null, headers, false);
+        NetworkResponse response = new NetworkResponse(0, null, false, 0, headers);
         Cache.Entry entry = HttpHeaderParser.parseCacheHeaders(response);
 
         assertNotNull(entry);
         assertEquals("Yow!", entry.etag);
         assertEqualsWithin(now + ONE_DAY_MILLIS, entry.ttl, ONE_MINUTE_MILLIS);
         assertEquals(entry.softTtl, entry.ttl);
-        assertEquals("ISO-8859-1", HttpHeaderParser.parseCharset(headers));
+        assertEquals("ISO-8859-1",
+                HttpHeaderParser.parseCharset(HttpHeaderParser.toHeaderMap(headers)));
     }
 }
diff --git a/src/test/java/com/android/volley/toolbox/HurlStackTest.java b/src/test/java/com/android/volley/toolbox/HurlStackTest.java
index 42aeea8..c8dd6f1 100644
--- a/src/test/java/com/android/volley/toolbox/HurlStackTest.java
+++ b/src/test/java/com/android/volley/toolbox/HurlStackTest.java
@@ -16,6 +16,7 @@
 
 package com.android.volley.toolbox;
 
+import com.android.volley.Header;
 import com.android.volley.Request.Method;
 import com.android.volley.mock.MockHttpURLConnection;
 import com.android.volley.mock.TestRequest;
@@ -25,6 +26,12 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import static org.junit.Assert.*;
 
 @RunWith(RobolectricTestRunner.class)
@@ -152,4 +159,20 @@ public class HurlStackTest {
         assertEquals("PATCH", mMockConnection.getRequestMethod());
         assertTrue(mMockConnection.getDoOutput());
     }
+
+    @Test public void convertHeaders() {
+        Map<String, List<String>> headers = new HashMap<>();
+        headers.put(null, Collections.singletonList("Ignored"));
+        headers.put("HeaderA", Collections.singletonList("ValueA"));
+        List<String> values = new ArrayList<>();
+        values.add("ValueB_1");
+        values.add("ValueB_2");
+        headers.put("HeaderB", values);
+        List<Header> result = HurlStack.convertHeaders(headers);
+        List<Header> expected = new ArrayList<>();
+        expected.add(new Header("HeaderA", "ValueA"));
+        expected.add(new Header("HeaderB", "ValueB_1"));
+        expected.add(new Header("HeaderB", "ValueB_2"));
+        assertEquals(expected, result);
+    }
 }