Java tutorial
/* * Copyright (C) 2007 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 java.util.ArrayList; import java.util.Map; import org.apache.http.protocol.HTTP; import android.util.Log; import android.net.http.*; /** * Implements EventHandler and provides test functionality to validate * responses to requests from the test server */ public class TestEventHandler implements EventHandler { /** * Status variables */ private int majorVersion = -1; private int minorVersion = -1; private int responseCode = -1; private String reasonPhrase; /* List of headers received */ private Map<String, String> headerMap; /* Used to sync low level delayed requests */ public static final Object syncObj = new Object(); /* Indicates whether the low level request testing is in operation */ private boolean useLowLevel = false; /* Indicates whether responses should be automatically generated or * delayed */ private boolean delayResponse = false; /* Test method expectation identifiers */ public final static int TEST_REQUEST_SENT = 0; public final static int TEST_STATUS = 1; public final static int TEST_HEADERS = 2; public final static int TEST_LOCATION_CHANGED = 3; public final static int TEST_DATA = 4; public final static int TEST_ENDDATA = 5; public final static int TEST_ERROR = 6; public final static int TEST_SSL_CERTIFICATE_ERROR = 7; public final static int TEST_NUM_EXPECTS = 8; /* Expected status codes */ private int expectMajor = -1; private int expectMinor = -1; private int expectCode = -1; /* Array indicating which event types are expected */ private boolean[] expects = new boolean[TEST_NUM_EXPECTS]; /* Array indicating which event types are not expected */ private boolean[] notExpecting = new boolean[TEST_NUM_EXPECTS]; /* Indicates which events have been received */ private boolean[] eventsReceived = new boolean[TEST_NUM_EXPECTS]; /* Redirection variables */ private String expectLocation; private int expectPermanent = -1; /* Content data expected to be received */ private byte[] expectData; private int expectDataLength = -1; private int expectErrorId = -1; private int expectSslErrors = -1; private SslCertificate expectCertificate; public class TestHeader { public TestHeader(String n, String v) { name = n; value = v; } public String name; public String value; } private ArrayList<TestHeader> expectHeaders = new ArrayList<TestHeader>(); /* Holds failure details */ private StringBuffer expectDetails = new StringBuffer(); /* If we use a request handle, we retain a reference here for redirects * using setupRedirect */ private RequestHandle mRequestHandle; /* The low level API uses this reference also for non-delayed requests */ private LowLevelNetRunner netRunner; public TestEventHandler() { for (int i = 0; i < TEST_NUM_EXPECTS; i++) { expects[i] = false; notExpecting[i] = false; eventsReceived[i] = false; } } /** * Implementation of EventHandler method called when a request has been * sent. If the test is waiting for this call, it will be signalled, * otherwise this method will trigger the response to be read * automatically. */ public void requestSent() { Log.v(LOGTAG, "TestEventHandler:requestSent()"); expects[TEST_REQUEST_SENT] = false; eventsReceived[TEST_REQUEST_SENT] = true; if (notExpecting[TEST_REQUEST_SENT]) { expectDetails.append("Request sent event received but not expected"); expectDetails.append("\r\n"); } if (useLowLevel) { if (delayResponse) { synchronized (syncObj) { syncObj.notifyAll(); } } else { // mRequest.startReadingResponse(); } } } /** * Implements the EventHandler status method called when a server status * response is received. * @param major_version The HTTP major version * @param minor_version The HTTP minor version * @param code The status code * @param reason_phrase A reason phrase passed to us by the server */ public void status(int major_version, int minor_version, int code, String reason_phrase) { if (false) { Log.v(LOGTAG, "TestEventHandler:status() major: " + major_version + " minor: " + minor_version + " code: " + code + " reason: " + reason_phrase); } eventsReceived[TEST_STATUS] = true; if (notExpecting[TEST_STATUS]) { expectDetails.append("Status event received but not expected"); expectDetails.append("\r\n"); } majorVersion = major_version; minorVersion = minor_version; responseCode = code; reasonPhrase = reason_phrase; if (expectMajor != -1) { if (expectMajor == major_version) { expectMajor = -1; } else { expectDetails.append("Major version expected:" + expectMajor + " got:" + major_version); expectDetails.append("\r\n"); } } if (expectMinor != -1) { if (expectMinor == minor_version) { expectMinor = -1; } else { expectDetails.append("Minor version expected:" + expectMinor + " got:" + minor_version); expectDetails.append("\r\n"); } } if (expectCode != -1) { if (expectCode == code) { expectCode = -1; } else { expectDetails.append("Status code expected:" + expectCode + " got:" + code); expectDetails.append("\r\n"); } } if ((expectMajor == -1) && (expectMinor == -1) && (expectCode == -1)) { expects[TEST_STATUS] = false; } else { System.out.println("MAJOR = " + expectMajor + " MINOR = " + expectMinor + " CODE = " + expectCode); } } /** * Implements the EventHandler headers method called when a server * sends header fields */ public void headers(Headers headers) { if (false) { Log.v(LOGTAG, "TestEventHandler:headers()"); } expects[TEST_HEADERS] = false; if (notExpecting[TEST_HEADERS]) { expectDetails.append("Header event received but not expected"); expectDetails.append("\r\n"); } /* Check through headers received for matches with expected * headers */ if (expectHeaders.isEmpty()) { return; } for (int i = expectHeaders.size() - 1; i >= 0; i--) { TestHeader h = expectHeaders.get(i); System.out.println("Expected header name: " + h.name); String s = null; switch (h.name.hashCode()) { case -1132779846: s = Long.toString(headers.getContentLength()); break; case 785670158: s = headers.getContentType(); break; case 2095084583: s = headers.getContentEncoding(); break; case 1901043637: s = headers.getLocation(); break; case -243037365: s = headers.getWwwAuthenticate(); break; case -301767724: s = headers.getProxyAuthenticate(); break; case -1267267485: s = headers.getContentDisposition(); break; case 1397189435: s = headers.getAcceptRanges(); break; case -1309235404: s = headers.getExpires(); break; case -208775662: s = headers.getCacheControl(); break; case 150043680: s = headers.getLastModified(); break; case 3123477: s = headers.getEtag(); break; case -775651618: int ct = headers.getConnectionType(); if (ct == Headers.CONN_CLOSE) { s = HTTP.CONN_CLOSE; } else if (ct == Headers.CONN_KEEP_ALIVE) { s = HTTP.CONN_KEEP_ALIVE; } break; default: s = null; } if (evaluateHeader(h, s)) { expectHeaders.remove(i); } } } public boolean evaluateHeader(TestHeader h, String value) { if (value == null) { expects[TEST_HEADERS] = true; System.out.print(" Missing! "); expectDetails.append(" missing header " + h.name); return false; } if (h.value == null) { System.out.println("Expect value = null"); return true; } System.out.println("Expect value = " + (h.value.toLowerCase()) + " got " + value.toLowerCase()); if (!h.value.equalsIgnoreCase(value)) { expectDetails.append("expect header value " + h.value + " got " + value); expects[TEST_HEADERS] = true; return false; } return true; } /** * Implements the EventHandler locationChanged method called when a server * sends a redirect message * @param newLocation The URL to the new server * @param permanent Indicator of whether this is a permanent change */ public void locationChanged(String newLocation, boolean permanent) { if (false) { Log.v(LOGTAG, "TestEventHandler: locationChanged() " + newLocation + " permanent " + permanent); } eventsReceived[TEST_LOCATION_CHANGED] = true; if (notExpecting[TEST_LOCATION_CHANGED]) { expectDetails.append("Location changed event received but " + "not expected"); expectDetails.append("\r\n"); } if (expectLocation != null) { if (expectLocation.equals(newLocation)) { expectLocation = null; } else { expectDetails.append("Location expected:" + expectLocation + " got:" + newLocation); expectDetails.append("\r\n"); } } if (expectPermanent != -1) { if (((expectPermanent == 0) && !permanent) || ((expectPermanent == 1) && permanent)) { expectPermanent = -1; } else { expectDetails.append("Location permanent expected:" + expectPermanent + " got" + permanent); expectDetails.append("\r\n"); } } if ((expectLocation == null) && (expectPermanent == -1)) expects[TEST_LOCATION_CHANGED] = false; } /** * Implements the EventHandler data method called when a server * sends content data * @param data The byte array content * @param len The length of the data */ public void data(byte[] data, int len) { boolean mismatch = false; if (false) { Log.v(LOGTAG, "TestEventHandler: data() " + len + " bytes"); } eventsReceived[TEST_DATA] = true; if (notExpecting[TEST_DATA]) { expectDetails.append("Data event received but not expected"); expectDetails.append("\r\n"); } Log.v(LOGTAG, new String(data, 0, len)); if (expectDataLength != -1) { if (expectDataLength == len) { expectDataLength = -1; } else { expectDetails.append("expect data length mismatch expected:" + expectDataLength + " got:" + len); expectDetails.append("\r\n"); } /* Check data only if length is the same */ if ((expectDataLength == -1) && expectData != null) { for (int i = 0; i < len; i++) { if (expectData[i] != data[i]) { mismatch = true; expectDetails.append("Expect data mismatch at byte " + i + " expected:" + expectData[i] + " got:" + data[i]); expectDetails.append("\r\n"); break; } } } } if ((expectDataLength == -1) || !mismatch) expects[TEST_DATA] = false; } /** * Implements the EventHandler endData method called to * indicate completion or a request */ public void endData() { if (false) { Log.v(LOGTAG, "TestEventHandler: endData() called"); } eventsReceived[TEST_ENDDATA] = true; if (notExpecting[TEST_ENDDATA]) { expectDetails.append("End data event received but not expected"); expectDetails.append("\r\n"); } expects[TEST_ENDDATA] = false; if (useLowLevel) { if (delayResponse) { synchronized (syncObj) { syncObj.notifyAll(); } } else { if (netRunner != null) { System.out.println("TestEventHandler: endData() stopping " + netRunner); netRunner.decrementRunCount(); } } } } /** * Implements the EventHandler certificate method called every * time a resource is loaded via a secure connection */ public void certificate(SslCertificate certificate) { } /** * Implements the EventHandler error method called when a server * sends header fields * @param id Status code of the error * @param description Brief description of the error */ public void error(int id, String description) { if (false) { Log.v(LOGTAG, "TestEventHandler: error() called Id:" + id + " description " + description); } eventsReceived[TEST_ERROR] = true; if (notExpecting[TEST_ERROR]) { expectDetails.append("Error event received but not expected"); expectDetails.append("\r\n"); } if (expectErrorId != -1) { if (expectErrorId == id) { expectErrorId = -1; } else { expectDetails.append("Error Id expected:" + expectErrorId + " got:" + id); expectDetails.append("\r\n"); } } if (expectErrorId == -1) expects[TEST_ERROR] = false; if (useLowLevel) { if (delayResponse) { synchronized (syncObj) { syncObj.notifyAll(); } } else { if (netRunner != null) { System.out.println("TestEventHandler: endData() stopping " + netRunner); netRunner.decrementRunCount(); } } } } /** * SSL certificate error callback. Handles SSL error(s) on the way * up to the user. */ public boolean handleSslErrorRequest(SslError error) { int primaryError = error.getPrimaryError(); if (false) { Log.v(LOGTAG, "TestEventHandler: handleSslErrorRequest(): " + " primary error:" + primaryError + " certificate: " + error.getCertificate()); } eventsReceived[TEST_SSL_CERTIFICATE_ERROR] = true; if (notExpecting[TEST_SSL_CERTIFICATE_ERROR]) { expectDetails.append("SSL Certificate error event received " + "but not expected"); expectDetails.append("\r\n"); } if (expectSslErrors != -1) { if (expectSslErrors == primaryError) { expectSslErrors = -1; } else { expectDetails .append("SslCertificateError id expected:" + expectSslErrors + " got: " + primaryError); expectDetails.append("\r\n"); } } // SslCertificate match here? if (expectSslErrors == -1) // && expectSslCertificate == certificate? expects[TEST_SSL_CERTIFICATE_ERROR] = false; // return false so that we won't block the thread return false; } /** * Use the low level net runner with no delayed response * @param runner The LowLevelNetRunner object */ public void setNetRunner(LowLevelNetRunner runner) { setNetRunner(runner, false); } /** * Use the low level net runner and specify if the response * should be delayed * @param runner The LowLevelNetRunner object * @param delayedResponse Set to true is you will use the * waitForRequestSent/waitForRequestResponse routines */ public void setNetRunner(LowLevelNetRunner runner, boolean delayedResponse) { netRunner = runner; useLowLevel = true; delayResponse = delayedResponse; if (!delayResponse) netRunner.incrementRunCount(); } /** * Enable this listeners Request object to read server responses. * This should only be used in conjunction with setDelayResponse(true) */ public void waitForRequestResponse() { if (!delayResponse || !useLowLevel) { Log.d(LOGTAG, " Cant do this without delayReponse set "); return; } //if (mRequest != null) { // mRequest.startReadingResponse(); // } /* Now wait for the response to be completed either through endData * or an error */ synchronized (syncObj) { try { syncObj.wait(); } catch (InterruptedException e) { } } } /** * Enable this listeners Request object to read server responses. * This should only be used in conjunction with setDelayResponse(true) */ public void waitForRequestSent() { if (!delayResponse || !useLowLevel) { Log.d(LOGTAG, " Cant do this without delayReponse set "); return; } /* Now wait for the response to be completed either through endData * or an error */ synchronized (syncObj) { try { syncObj.wait(); } catch (InterruptedException e) { } } } /* Test expected values - these routines set the tests expectations */ public void expectRequestSent() { expects[TEST_REQUEST_SENT] = true; } public void expectNoRequestSent() { notExpecting[TEST_REQUEST_SENT] = true; } public void expectStatus() { expects[TEST_STATUS] = true; } public void expectNoStatus() { notExpecting[TEST_STATUS] = true; } public void expectStatus(int major, int minor, int code) { expects[TEST_STATUS] = true; expectMajor = major; expectMinor = minor; expectCode = code; } public void expectStatus(int code) { expects[TEST_STATUS] = true; expectCode = code; } public void expectHeaders() { expects[TEST_HEADERS] = true; } public void expectNoHeaders() { notExpecting[TEST_HEADERS] = true; } public void expectHeaderAdd(String name) { expects[TEST_HEADERS] = true; TestHeader h = new TestHeader(name.toLowerCase(), null); expectHeaders.add(h); } public void expectHeaderAdd(String name, String value) { expects[TEST_HEADERS] = true; TestHeader h = new TestHeader(name.toLowerCase(), value); expectHeaders.add(h); } public void expectLocationChanged() { expects[TEST_LOCATION_CHANGED] = true; } public void expectNoLocationChanged() { notExpecting[TEST_LOCATION_CHANGED] = true; } public void expectLocationChanged(String newLocation) { expects[TEST_LOCATION_CHANGED] = true; expectLocation = newLocation; } public void expectLocationChanged(String newLocation, boolean permanent) { expects[TEST_LOCATION_CHANGED] = true; expectLocation = newLocation; expectPermanent = permanent ? 1 : 0; } public void expectData() { expects[TEST_DATA] = true; } public void expectNoData() { notExpecting[TEST_DATA] = true; } public void expectData(int len) { expects[TEST_DATA] = true; expectDataLength = len; } public void expectData(byte[] data, int len) { expects[TEST_DATA] = true; expectData = new byte[len]; expectDataLength = len; for (int i = 0; i < len; i++) { expectData[i] = data[i]; } } public void expectEndData() { expects[TEST_ENDDATA] = true; } public void expectNoEndData() { notExpecting[TEST_ENDDATA] = true; } public void expectError() { expects[TEST_ERROR] = true; } public void expectNoError() { notExpecting[TEST_ERROR] = true; } public void expectError(int errorId) { expects[TEST_ERROR] = true; expectErrorId = errorId; } public void expectSSLCertificateError() { expects[TEST_SSL_CERTIFICATE_ERROR] = true; } public void expectNoSSLCertificateError() { notExpecting[TEST_SSL_CERTIFICATE_ERROR] = true; } public void expectSSLCertificateError(int errors) { expects[TEST_SSL_CERTIFICATE_ERROR] = true; expectSslErrors = errors; } public void expectSSLCertificateError(SslCertificate certificate) { expects[TEST_SSL_CERTIFICATE_ERROR] = true; expectCertificate = certificate; } /** * Test to see if current expectations match recieved information * @return True is all expected results have been matched */ public boolean expectPassed() { for (int i = 0; i < TEST_NUM_EXPECTS; i++) { if (expects[i] == true) { return false; } } for (int i = 0; i < TEST_NUM_EXPECTS; i++) { if (eventsReceived[i] && notExpecting[i]) { return false; } } return true; } /** * Return message indicating expectation failures */ public String getFailureMessage() { return expectDetails.toString(); } /** * Reset all expectation values for re-use */ public void resetExpects() { expectMajor = -1; expectMinor = -1; expectCode = -1; expectLocation = null; expectPermanent = -1; expectErrorId = -1; expectSslErrors = -1; expectCertificate = null; expectDetails.setLength(0); expectHeaders.clear(); for (int i = 0; i < TEST_NUM_EXPECTS; i++) { expects[i] = false; notExpecting[i] = false; eventsReceived[i] = false; } for (int i = 0; i < expectDataLength; i++) { expectData[i] = 0; } expectDataLength = -1; } /** * Attach the RequestHandle to this handler * @param requestHandle The RequestHandle */ public void attachRequestHandle(RequestHandle requestHandle) { if (false) { Log.v(LOGTAG, "TestEventHandler.attachRequestHandle(): " + "requestHandle: " + requestHandle); } mRequestHandle = requestHandle; } /** * Detach the RequestHandle */ public void detachRequestHandle() { if (false) { Log.v(LOGTAG, "TestEventHandler.detachRequestHandle(): " + "requestHandle: " + mRequestHandle); } mRequestHandle = null; } protected final static String LOGTAG = "http"; }