/*
* 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.mms;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Random;
import com.android.mms.data.Contact;
import com.android.mms.util.Recycler;
import android.provider.Telephony.Sms;
import android.provider.Telephony.Threads;
import android.provider.Telephony.Sms.Inbox;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SqliteWrapper;
import android.net.Uri;
import android.provider.Telephony.Sms.Conversations;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.LargeTest;
import android.util.Log;
/**
* Bang on the recycler and test it getting called simultaneously from two different threads
* NOTE: you first have to put the unix words file on the device:
* example: adb push ~/words /data/data/com.android.mms/files
* and then push a file that contains a comma separated list of numbers to send to.
* example: adb push ~/recipients /data/data/com.android.mms/files
*
*/
/**
* Bang on the recycler and test it getting called simultaneously from two different threads
* NOTE: you first have to put the unix words file on the device:
* example: adb push ~/words /data/data/com.android.mms/files
* and then push a file that contains a comma separated list of numbers to send to.
* example: adb push ~/recipients /data/data/com.android.mms/files
*
* To run just this test:
* runtest --test-class=com.android.mms.RecyclerTest mms
*/
public class RecyclerTest extends AndroidTestCase {
static final String TAG = "RecyclerTest";
private ArrayList<String> mWords;
private ArrayList<String> mRecipients;
private int mWordCount;
private Random mRandom = new Random();
private int mRecipientCnt;
private static final Uri sAllThreadsUri =
Threads.CONTENT_URI.buildUpon().appendQueryParameter("simple", "true").build();
private static final String[] ALL_THREADS_PROJECTION = {
Threads._ID, Threads.DATE, Threads.MESSAGE_COUNT, Threads.RECIPIENT_IDS,
Threads.SNIPPET, Threads.SNIPPET_CHARSET, Threads.READ, Threads.ERROR,
Threads.HAS_ATTACHMENT
};
@Override
protected void setUp() throws Exception {
super.setUp();
Context context = getContext();
// Read in dictionary of words
mWords = new ArrayList<String>(98568); // count of words in words file
StringBuilder sb = new StringBuilder();
try {
Log.v(TAG, "Loading dictionary of words");
FileInputStream words = context.openFileInput("words");
int c;
while ((c = words.read()) != -1) {
if (c == '\r' || c == '\n') {
String word = sb.toString().trim();
if (word.length() > 0) {
mWords.add(word);
}
sb.setLength(0);
} else {
sb.append((char)c);
}
}
words.close();
mWordCount = mWords.size();
Log.v(TAG, "Loaded dictionary word count: " + mWordCount);
} catch (Exception e) {
Log.e(TAG, "can't open words file at /data/data/com.android.mms/files/words");
return;
}
// Read in list of recipients
mRecipients = new ArrayList<String>();
try {
Log.v(TAG, "Loading recipients");
FileInputStream recipients = context.openFileInput("recipients");
int c;
while ((c = recipients.read()) != -1) {
if (c == '\r' || c == '\n' || c == ',') {
String recipient = sb.toString().trim();
if (recipient.length() > 0) {
mRecipients.add(recipient);
}
sb.setLength(0);
} else {
sb.append((char)c);
}
}
recipients.close();
Log.v(TAG, "Loaded recipients: " + mRecipients.size());
} catch (Exception e) {
Log.e(TAG, "can't open recipients file at /data/data/com.android.mms/files/recipients");
return;
}
mRecipientCnt = mRecipients.size();
}
private String generateMessage() {
int wordsInMessage = mRandom.nextInt(9) + 1; // up to 10 words in the message
StringBuilder msg = new StringBuilder();
for (int i = 0; i < wordsInMessage; i++) {
msg.append(mWords.get(mRandom.nextInt(mWordCount)) + " ");
}
return msg.toString();
}
private Uri storeMessage(Context context, String address, String message) {
// Store the message in the content provider.
ContentValues values = new ContentValues();
// values.put(Sms.ERROR_CODE, 0);
values.put(Inbox.ADDRESS, address);
// Use now for the timestamp to avoid confusion with clock
// drift between the handset and the SMSC.
values.put(Inbox.DATE, new Long(System.currentTimeMillis()));
values.put(Inbox.PROTOCOL, 0);
values.put(Inbox.READ, Integer.valueOf(0));
// if (sms.getPseudoSubject().length() > 0) {
// values.put(Inbox.SUBJECT, sms.getPseudoSubject());
// }
values.put(Inbox.REPLY_PATH_PRESENT, 0);
values.put(Inbox.SERVICE_CENTER, 0);
values.put(Inbox.BODY, message);
// Make sure we've got a thread id so after the insert we'll be able to delete
// excess messages.
Long threadId = 0L;
Contact cacheContact = Contact.get(address,true);
if (cacheContact != null) {
address = cacheContact.getNumber();
}
if (((threadId == null) || (threadId == 0)) && (address != null)) {
values.put(Sms.THREAD_ID, Threads.getOrCreateThreadId(
context, address));
}
ContentResolver resolver = context.getContentResolver();
Uri insertedUri = SqliteWrapper.insert(context, resolver, Inbox.CONTENT_URI, values);
// Now make sure we're not over the limit in stored messages
threadId = values.getAsLong(Sms.THREAD_ID);
Recycler.getSmsRecycler().deleteOldMessagesByThreadId(context, threadId);
return insertedUri;
}
Runnable mRecyclerBang = new Runnable() {
public void run() {
final int MAXSEND = Integer.MAX_VALUE;
for (int i = 0; i < MAXSEND; i++) {
// Put a random message to one of the random recipients in the SMS db.
Uri uri = storeMessage(getContext(),
mRecipients.get(mRandom.nextInt(mRecipientCnt)),
generateMessage());
Log.v(TAG, "Generating msg uri: " + uri);
if (i > 100) {
// Wait until we've sent a bunch of messages to guarantee we've got
// some threads built up. Then check to make sure all the threads are there
// on each message. All these queries will provide additional stress on the
// sms db.
Cursor cursor = null;
try {
cursor = SqliteWrapper.query(getContext(),
getContext().getContentResolver(), sAllThreadsUri,
ALL_THREADS_PROJECTION, null, null,
Conversations.DEFAULT_SORT_ORDER);
assertNotNull("Cursor from thread query is null!", cursor);
int cnt = cursor.getCount();
assertTrue("The threads appeared to have been wiped out",
cursor.getCount() >= mRecipientCnt);
} catch (SQLiteException e) {
Log.v(TAG, "query for threads failed with exception: " + e);
fail("query for threads failed with exception: " + e);
} finally {
if (cursor != null) {
cursor.close();
}
}
}
}
}
};
Runnable mSQLMemoryReleaser = new Runnable() {
public void run() {
while (true) {
SQLiteDatabase.releaseMemory();
try {
Thread.sleep(5000);
} catch (Exception e) {
}
}
}
};
/**
* Send a flurry of SMS and MMS messages
*/
@LargeTest
public void testRecycler() throws Throwable {
// Start N simultaneous threads generating messages and running the recycler
final int THREAD_COUNT = 3;
ArrayList<Thread> threads = new ArrayList<Thread>(THREAD_COUNT);
for (int i = 0; i < THREAD_COUNT; i++) {
threads.add(i, new Thread(mRecyclerBang));
threads.get(i).start();
}
Thread memoryBanger = new Thread(mSQLMemoryReleaser);
memoryBanger.start();
// Wait for the threads to finish
for (int i = 0; i < THREAD_COUNT; i++) {
threads.get(i).join();
}
assertTrue(true);
}
}