Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

auto import from //depot/cupcake/@132589

Browse Source
This commit is contained in:
The Android Open Source Project
2009-03-03 14:04:24 -08:00
parent 3dec7d563a
commit 076357b856
310 changed files with 4072 additions and 18131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
tests/AndroidTests/src/com/android/unit_tests/AppCacheTest.java
View File

@@ -121,7 +121,6 @@ public class AppCacheTest extends AndroidTestCase {
}
@LargeTest
public void testFreeApplicationCacheAllFiles() throws Exception {
boolean TRACKING = true;
StatFs st = new StatFs("/data");
long blks1 = getFreeStorageBlks(st);
long availableMem = getFreeStorageSize(st);
@@ -129,11 +128,11 @@ public class AppCacheTest extends AndroidTestCase {
assertNotNull(cacheDir);
createTestFiles1(cacheDir, "testtmpdir", 5);
long blks2 = getFreeStorageBlks(st);
if(localLOGV || TRACKING) Log.i(TAG, "blk1="+blks1+", blks2="+blks2);
if(localLOGV) Log.i(TAG, "blk1="+blks1+", blks2="+blks2);
//this should free up the test files that were created earlier
invokePMFreeApplicationCache(availableMem);
long blks3 = getFreeStorageBlks(st);
if(localLOGV || TRACKING) Log.i(TAG, "blks3="+blks3);
if(localLOGV) Log.i(TAG, "blks3="+blks3);
verifyTestFiles1(cacheDir, "testtmpdir", 5);
}
@@ -630,16 +629,15 @@ public class AppCacheTest extends AndroidTestCase {
@SmallTest
public void testFreeStorage() throws Exception {
boolean TRACKING = true;
StatFs st = new StatFs("/data");
long blks1 = getFreeStorageBlks(st);
if(localLOGV || TRACKING) Log.i(TAG, "Available free blocks="+blks1);
if(localLOGV) Log.i(TAG, "Available free blocks="+blks1);
long availableMem = getFreeStorageSize(st);
File cacheDir = mContext.getCacheDir();
assertNotNull(cacheDir);
createTestFiles1(cacheDir, "testtmpdir", 5);
long blks2 = getFreeStorageBlks(st);
if(localLOGV || TRACKING) Log.i(TAG, "Available blocks after writing test files in application cache="+blks2);
if(localLOGV) Log.i(TAG, "Available blocks after writing test files in application cache="+blks2);
// Create receiver and register it
FreeStorageReceiver receiver = new FreeStorageReceiver();
mContext.registerReceiver(receiver, new IntentFilter(FreeStorageReceiver.ACTION_FREE));
@@ -648,7 +646,7 @@ public class AppCacheTest extends AndroidTestCase {
// Invoke PackageManager api
invokePMFreeStorage(availableMem, receiver, pi);
long blks3 = getFreeStorageBlks(st);
if(localLOGV || TRACKING) Log.i(TAG, "Available blocks after freeing cache"+blks3);
if(localLOGV) Log.i(TAG, "Available blocks after freeing cache"+blks3);
assertEquals(receiver.getResultCode(), 1);
mContext.unregisterReceiver(receiver);
// Verify result

273
tests/AndroidTests/src/com/android/unit_tests/DbSSLSessionCacheTest.java
View File

@@ -1,273 +0,0 @@
/*
* 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 com.android.unit_tests;
import android.content.ContentResolver;
import android.database.Cursor;
import android.database.sqlite.SQLiteOpenHelper;
import android.provider.Settings;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.LargeTest;
import android.test.suitebuilder.annotation.Suppress;
import com.google.android.net.GoogleHttpClient;
import com.android.internal.net.DbSSLSessionCache;
import com.android.internal.net.SSLSessionCache;
import com.android.internal.net.DbSSLSessionCache.DatabaseHelper;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import java.io.IOException;
import java.security.Principal;
import java.security.cert.Certificate;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSessionContext;
import javax.security.cert.X509Certificate;
/** Unit test for SSL session caching with {@link GoogleHttpClient}.
* Uses network resources.
*/
@Suppress
public class DbSSLSessionCacheTest extends AndroidTestCase {
protected void setUp() throws Exception {
}
protected void tearDown() throws Exception {
}
@LargeTest
public void testSslCacheSettings() throws Exception {
ContentResolver resolver = getContext().getContentResolver();
Settings.Gservices.putString(resolver, Settings.Gservices.SSL_SESSION_CACHE,
"0");
assertFalse(SSLSessionCache.isEnabled(getContext().getContentResolver()));
resolver = getContext().getContentResolver();
Settings.Gservices.putString(resolver, Settings.Gservices.SSL_SESSION_CACHE,
"db");
assertTrue(SSLSessionCache.isEnabled(getContext().getContentResolver()));
}
/**
* We want to test the actual database write - the actual hooking into
* low-level SSL is tested.
*/
@LargeTest
public void testSslCacheAdd() throws Exception {
// Let's verify the database has the rows.
// Use internal details of the implementation - could make the field
// visible for testing, but it's same.
// Use default database
DbSSLSessionCache cache = new DbSSLSessionCache(getContext());
cache.clear();
makeRequestInNewContext("https://www.google.com");
// Verify the key was inserted
SQLiteOpenHelper helper = new DatabaseHelper(getContext());
Cursor query = null;
try {
query = helper.getReadableDatabase().query(DbSSLSessionCache.SSL_CACHE_TABLE,
new String[] {"hostport"}, null,
null, null, null, null);
assertTrue(query.moveToFirst()); // one row inserted
String hostPort = query.getString(0);
assertEquals(hostPort, "www.google.com:443");
} finally {
query.close();
}
}
@LargeTest
public void testExpire() throws Exception {
DatabaseHelper helper = new DatabaseHelper(getContext());
// clean up
DbSSLSessionCache cache = new DbSSLSessionCache(helper);
cache.clear();
long t0 = System.currentTimeMillis();
for (int i = 0; i < DbSSLSessionCache.MAX_CACHE_SIZE + 2; i++) {
final int port = i;
cache.putSessionData(new MockSession() {
public String getPeerHost() {
return "test.host.com";
}
public int getPeerPort() {
return port;
}
}, new byte[256]);
}
long t1 = System.currentTimeMillis();
System.err.println("Time to insert " +
(DbSSLSessionCache.MAX_CACHE_SIZE + 2) + " " + (t1 - t0));
// first entry should have port 1.
Cursor query = helper.getReadableDatabase().query(DbSSLSessionCache.SSL_CACHE_TABLE,
new String[] {"hostport", "session"}, null,
null, null, null, null);
int cnt = query.getCount();
assertTrue(query.moveToFirst()); // one row inserted
String hostPort = query.getString(0);
assertEquals("test.host.com:2", hostPort);
while (query.moveToNext()) {
hostPort = query.getString(0);
String session = query.getString(1);
}
long t2 = System.currentTimeMillis();
System.err.println("Time to load " + cnt + " " + (t2 - t1));
query.close();
}
private void makeRequestInNewContext(String url) throws IOException {
GoogleHttpClient client = new GoogleHttpClient(getContext(), "Test",
false /* no gzip */);
try {
// Note: we must test against a real server, because the connection
// gets established before the interceptor can crash the request.
HttpGet method = new HttpGet(url);
HttpResponse response = client.execute(method);
} finally {
client.close();
}
}
private static class MockSession implements SSLSession {
public String getPeerHost() {
throw new UnsupportedOperationException();
}
public int getPeerPort() {
throw new UnsupportedOperationException();
}
public int getApplicationBufferSize() {
throw new UnsupportedOperationException();
}
public String getCipherSuite() {
throw new UnsupportedOperationException();
}
public long getCreationTime() {
throw new UnsupportedOperationException();
}
public byte[] getId() {
throw new UnsupportedOperationException();
}
public long getLastAccessedTime() {
throw new UnsupportedOperationException();
}
public Certificate[] getLocalCertificates() {
throw new UnsupportedOperationException();
}
public Principal getLocalPrincipal() {
throw new UnsupportedOperationException();
}
public int getPacketBufferSize() {
throw new UnsupportedOperationException();
}
public X509Certificate[] getPeerCertificateChain()
throws SSLPeerUnverifiedException {
throw new UnsupportedOperationException();
}
public Certificate[] getPeerCertificates() throws SSLPeerUnverifiedException {
throw new UnsupportedOperationException();
}
public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {
throw new UnsupportedOperationException();
}
public String getProtocol() {
throw new UnsupportedOperationException();
}
public SSLSessionContext getSessionContext() {
throw new UnsupportedOperationException();
}
public Object getValue(String name) {
throw new UnsupportedOperationException();
}
public String[] getValueNames() {
throw new UnsupportedOperationException();
}
public void invalidate() {
throw new UnsupportedOperationException();
}
public boolean isValid() {
throw new UnsupportedOperationException();
}
public void putValue(String name, Object value) {
throw new UnsupportedOperationException();
}
public void removeValue(String name) {
throw new UnsupportedOperationException();
}
}
}