mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
1663 lines
80 KiB
Java
1663 lines
80 KiB
Java
#filter substitution
|
|
package @ANDROID_PACKAGE_NAME@.tests;
|
|
|
|
import @ANDROID_PACKAGE_NAME@.*;
|
|
|
|
import android.content.ContentValues;
|
|
import android.content.ContentUris;
|
|
import android.content.ContentProviderResult;
|
|
import android.content.ContentProviderOperation;
|
|
import android.content.OperationApplicationException;
|
|
import android.database.Cursor;
|
|
import android.database.sqlite.SQLiteDatabase;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.util.Log;
|
|
|
|
import java.io.File;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.Random;
|
|
|
|
/*
|
|
* This test is meant to exercise all operations exposed by Fennec's
|
|
* history and bookmarks content provider. It does so in an isolated
|
|
* environment (see ContentProviderTest) without affecting any UI-related
|
|
* code.
|
|
*/
|
|
public class testBrowserProvider extends ContentProviderTest {
|
|
private String PLACES_FOLDER_GUID;
|
|
private String MOBILE_FOLDER_GUID;
|
|
private String MENU_FOLDER_GUID;
|
|
private String TAGS_FOLDER_GUID;
|
|
private String TOOLBAR_FOLDER_GUID;
|
|
private String UNFILED_FOLDER_GUID;
|
|
private String READING_LIST_FOLDER_GUID;
|
|
|
|
private Uri mBookmarksUri;
|
|
private Uri mBookmarksPositionUri;
|
|
private Uri mHistoryUri;
|
|
private Uri mHistoryOldUri;
|
|
private Uri mImagesUri;
|
|
private Uri mCombinedUri;
|
|
|
|
private String mBookmarksIdCol;
|
|
private String mBookmarksTitleCol;
|
|
private String mBookmarksUrlCol;
|
|
private String mBookmarksFaviconCol;
|
|
private String mBookmarksThumbnailCol;
|
|
private String mBookmarksParentCol;
|
|
private String mBookmarksTypeCol;
|
|
private String mBookmarksPositionCol;
|
|
private String mBookmarksTagsCol;
|
|
private String mBookmarksDescriptionCol;
|
|
private String mBookmarksKeywordCol;
|
|
private String mBookmarksGuidCol;
|
|
private String mBookmarksIsDeletedCol;
|
|
private String mBookmarksDateCreatedCol;
|
|
private String mBookmarksDateModifiedCol;
|
|
private int mBookmarksTypeFolder;
|
|
private int mBookmarksTypeBookmark;
|
|
private long mMobileFolderId;
|
|
|
|
private String mHistoryIdCol;
|
|
private String mHistoryTitleCol;
|
|
private String mHistoryUrlCol;
|
|
private String mHistoryVisitsCol;
|
|
private String mHistoryFaviconCol;
|
|
private String mHistoryThumbnailCol;
|
|
private String mHistoryLastVisitedCol;
|
|
private String mHistoryGuidCol;
|
|
private String mHistoryIsDeletedCol;
|
|
private String mHistoryDateCreatedCol;
|
|
private String mHistoryDateModifiedCol;
|
|
|
|
private String mImagesThumbnailCol;
|
|
private String mImagesFaviconCol;
|
|
private String mImagesUrlCol;
|
|
|
|
private String mCombinedIdCol;
|
|
private String mCombinedBookmarkIdCol;
|
|
private String mCombinedHistoryIdCol;
|
|
private String mCombinedDisplayCol;
|
|
private String mCombinedUrlCol;
|
|
private String mCombinedTitleCol;
|
|
private String mCombinedVisitsCol;
|
|
private String mCombinedLastVisitedCol;
|
|
private String mCombinedFaviconCol;
|
|
private String mCombinedThumbnailCol;
|
|
private int mCombinedDisplayNormal;
|
|
private int mCombinedDisplayReader;
|
|
|
|
@Override
|
|
protected int getTestType() {
|
|
return TEST_MOCHITEST;
|
|
}
|
|
|
|
private void loadContractInfo() throws Exception {
|
|
mBookmarksUri = getContentUri("Bookmarks");
|
|
mHistoryUri = getContentUri("History");
|
|
mHistoryOldUri = getUriColumn("History", "CONTENT_OLD_URI");
|
|
mImagesUri = getContentUri("Images");
|
|
mCombinedUri = getContentUri("Combined");
|
|
|
|
mBookmarksPositionUri = getUriColumn("Bookmarks", "POSITIONS_CONTENT_URI");
|
|
|
|
PLACES_FOLDER_GUID = getStringColumn("Bookmarks", "PLACES_FOLDER_GUID");
|
|
MOBILE_FOLDER_GUID = getStringColumn("Bookmarks", "MOBILE_FOLDER_GUID");
|
|
MENU_FOLDER_GUID = getStringColumn("Bookmarks", "MENU_FOLDER_GUID");
|
|
TAGS_FOLDER_GUID = getStringColumn("Bookmarks", "TAGS_FOLDER_GUID");
|
|
TOOLBAR_FOLDER_GUID = getStringColumn("Bookmarks", "TOOLBAR_FOLDER_GUID");
|
|
UNFILED_FOLDER_GUID = getStringColumn("Bookmarks", "UNFILED_FOLDER_GUID");
|
|
READING_LIST_FOLDER_GUID = getStringColumn("Bookmarks", "READING_LIST_FOLDER_GUID");
|
|
|
|
mBookmarksIdCol = getStringColumn("Bookmarks", "_ID");
|
|
mBookmarksTitleCol = getStringColumn("Bookmarks", "TITLE");
|
|
mBookmarksUrlCol = getStringColumn("Bookmarks", "URL");
|
|
mBookmarksFaviconCol = getStringColumn("Bookmarks", "FAVICON");
|
|
mBookmarksThumbnailCol = getStringColumn("Bookmarks", "THUMBNAIL");
|
|
mBookmarksParentCol = getStringColumn("Bookmarks", "PARENT");
|
|
mBookmarksTypeCol = getStringColumn("Bookmarks", "TYPE");
|
|
mBookmarksPositionCol = getStringColumn("Bookmarks", "POSITION");
|
|
mBookmarksTagsCol = getStringColumn("Bookmarks", "TAGS");
|
|
mBookmarksDescriptionCol = getStringColumn("Bookmarks", "DESCRIPTION");
|
|
mBookmarksKeywordCol= getStringColumn("Bookmarks", "KEYWORD");
|
|
mBookmarksGuidCol = getStringColumn("Bookmarks", "GUID");
|
|
mBookmarksIsDeletedCol = getStringColumn("Bookmarks", "IS_DELETED");
|
|
mBookmarksDateCreatedCol = getStringColumn("Bookmarks", "DATE_CREATED");
|
|
mBookmarksDateModifiedCol = getStringColumn("Bookmarks", "DATE_MODIFIED");
|
|
|
|
mBookmarksTypeFolder = getIntColumn("Bookmarks", "TYPE_FOLDER");
|
|
mBookmarksTypeBookmark = getIntColumn("Bookmarks", "TYPE_BOOKMARK");
|
|
|
|
mHistoryIdCol = getStringColumn("History", "_ID");
|
|
mHistoryTitleCol = getStringColumn("History", "TITLE");
|
|
mHistoryUrlCol = getStringColumn("History", "URL");
|
|
mHistoryVisitsCol = getStringColumn("History", "VISITS");
|
|
mHistoryLastVisitedCol = getStringColumn("History", "DATE_LAST_VISITED");
|
|
mHistoryFaviconCol = getStringColumn("History", "FAVICON");
|
|
mHistoryThumbnailCol = getStringColumn("History", "THUMBNAIL");
|
|
mHistoryGuidCol = getStringColumn("History", "GUID");
|
|
mHistoryIsDeletedCol = getStringColumn("History", "IS_DELETED");
|
|
mHistoryDateCreatedCol = getStringColumn("History", "DATE_CREATED");
|
|
mHistoryDateModifiedCol = getStringColumn("History", "DATE_MODIFIED");
|
|
|
|
mImagesUrlCol = getStringColumn("Images", "URL");
|
|
mImagesFaviconCol = getStringColumn("Images", "FAVICON");
|
|
mImagesThumbnailCol = getStringColumn("Images", "THUMBNAIL");
|
|
|
|
mCombinedIdCol = getStringColumn("Combined", "_ID");
|
|
mCombinedBookmarkIdCol = getStringColumn("Combined", "BOOKMARK_ID");
|
|
mCombinedHistoryIdCol = getStringColumn("Combined", "HISTORY_ID");
|
|
mCombinedDisplayCol = getStringColumn("Combined", "DISPLAY");
|
|
mCombinedUrlCol = getStringColumn("Combined", "URL");
|
|
mCombinedTitleCol = getStringColumn("Combined", "TITLE");
|
|
mCombinedVisitsCol = getStringColumn("Combined", "VISITS");
|
|
mCombinedLastVisitedCol = getStringColumn("Combined", "DATE_LAST_VISITED");
|
|
mCombinedFaviconCol = getStringColumn("Combined", "FAVICON");
|
|
mCombinedThumbnailCol = getStringColumn("Combined", "THUMBNAIL");
|
|
|
|
mCombinedDisplayNormal = getIntColumn("Combined", "DISPLAY_NORMAL");
|
|
mCombinedDisplayReader = getIntColumn("Combined", "DISPLAY_READER");
|
|
}
|
|
|
|
private void loadMobileFolderId() throws Exception {
|
|
Cursor c = getBookmarkByGuid(MOBILE_FOLDER_GUID);
|
|
mAsserter.is(c.moveToFirst(), true, "Mobile bookmarks folder is present");
|
|
|
|
mMobileFolderId = c.getLong(c.getColumnIndex(mBookmarksIdCol));
|
|
}
|
|
|
|
private void ensureEmptyDatabase() throws Exception {
|
|
Cursor c = null;
|
|
|
|
String guid = getStringColumn("Bookmarks", "GUID");
|
|
|
|
mProvider.delete(appendUriParam(mBookmarksUri, "PARAM_IS_SYNC", "1"),
|
|
guid + " != ? AND " +
|
|
guid + " != ? AND " +
|
|
guid + " != ? AND " +
|
|
guid + " != ? AND " +
|
|
guid + " != ? AND " +
|
|
guid + " != ? AND " +
|
|
guid + " != ?",
|
|
new String[] { PLACES_FOLDER_GUID,
|
|
MOBILE_FOLDER_GUID,
|
|
MENU_FOLDER_GUID,
|
|
TAGS_FOLDER_GUID,
|
|
TOOLBAR_FOLDER_GUID,
|
|
UNFILED_FOLDER_GUID,
|
|
READING_LIST_FOLDER_GUID });
|
|
|
|
c = mProvider.query(appendUriParam(mBookmarksUri, "PARAM_SHOW_DELETED", "1"), null, null, null, null);
|
|
mAsserter.is(c.getCount(), 7, "All non-special bookmarks and folders were deleted");
|
|
|
|
mProvider.delete(appendUriParam(mHistoryUri, "PARAM_IS_SYNC", "1"), null, null);
|
|
c = mProvider.query(appendUriParam(mHistoryUri, "PARAM_SHOW_DELETED", "1"), null, null, null, null);
|
|
mAsserter.is(c.getCount(), 0, "All history entries were deleted");
|
|
|
|
mProvider.delete(appendUriParam(mImagesUri, "PARAM_IS_SYNC", "1"), null, null);
|
|
c = mProvider.query(appendUriParam(mImagesUri, "PARAM_SHOW_DELETED", "1"), null, null, null, null);
|
|
mAsserter.is(c.getCount(), 0, "All images were deleted");
|
|
}
|
|
|
|
private ContentValues createBookmark(String title, String url, long parentId,
|
|
int type, int position, String tags, String description, String keyword) throws Exception {
|
|
ContentValues bookmark = new ContentValues();
|
|
|
|
bookmark.put(mBookmarksTitleCol, title);
|
|
bookmark.put(mBookmarksUrlCol, url);
|
|
bookmark.put(mBookmarksParentCol, parentId);
|
|
bookmark.put(mBookmarksTypeCol, type);
|
|
bookmark.put(mBookmarksPositionCol, position);
|
|
bookmark.put(mBookmarksTagsCol, tags);
|
|
bookmark.put(mBookmarksDescriptionCol, description);
|
|
bookmark.put(mBookmarksKeywordCol, keyword);
|
|
|
|
return bookmark;
|
|
}
|
|
|
|
private ContentValues createOneBookmark() throws Exception {
|
|
return createBookmark("Example", "http://example.com", mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
}
|
|
|
|
private Cursor getBookmarksByParent(long parent) throws Exception {
|
|
// Order by position.
|
|
return mProvider.query(mBookmarksUri, null,
|
|
mBookmarksParentCol + " = ?",
|
|
new String[] { String.valueOf(parent) },
|
|
mBookmarksPositionCol);
|
|
}
|
|
|
|
private Cursor getBookmarkByGuid(String guid) throws Exception {
|
|
return mProvider.query(mBookmarksUri, null,
|
|
mBookmarksGuidCol + " = ?",
|
|
new String[] { guid },
|
|
null);
|
|
}
|
|
|
|
private Cursor getBookmarkById(long id) throws Exception {
|
|
return getBookmarkById(mBookmarksUri, id, null);
|
|
}
|
|
|
|
private Cursor getBookmarkById(long id, String[] projection) throws Exception {
|
|
return getBookmarkById(mBookmarksUri, id, projection);
|
|
}
|
|
|
|
private Cursor getBookmarkById(Uri bookmarksUri, long id) throws Exception {
|
|
return getBookmarkById(bookmarksUri, id, null);
|
|
}
|
|
|
|
private Cursor getBookmarkById(Uri bookmarksUri, long id, String[] projection) throws Exception {
|
|
return mProvider.query(bookmarksUri, projection,
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(id) },
|
|
null);
|
|
}
|
|
|
|
private ContentValues createHistoryEntry(String title, String url, int visits, long lastVisited) throws Exception {
|
|
ContentValues historyEntry = new ContentValues();
|
|
|
|
historyEntry.put(mHistoryTitleCol, title);
|
|
historyEntry.put(mHistoryUrlCol, url);
|
|
historyEntry.put(mHistoryVisitsCol, visits);
|
|
historyEntry.put(mHistoryLastVisitedCol, lastVisited);
|
|
|
|
return historyEntry;
|
|
}
|
|
|
|
private ContentValues createOneHistoryEntry() throws Exception {
|
|
return createHistoryEntry("Example", "http://example.com", 10, System.currentTimeMillis());
|
|
}
|
|
|
|
private Cursor getHistoryEntryById(long id) throws Exception {
|
|
return getHistoryEntryById(mHistoryUri, id, null);
|
|
}
|
|
|
|
private Cursor getHistoryEntryById(long id, String[] projection) throws Exception {
|
|
return getHistoryEntryById(mHistoryUri, id, projection);
|
|
}
|
|
|
|
private Cursor getHistoryEntryById(Uri historyUri, long id) throws Exception {
|
|
return getHistoryEntryById(historyUri, id, null);
|
|
}
|
|
|
|
private Cursor getHistoryEntryById(Uri historyUri, long id, String[] projection) throws Exception {
|
|
return mProvider.query(historyUri, projection,
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) },
|
|
null);
|
|
}
|
|
|
|
private Cursor getImagesByUrl(String url) throws Exception {
|
|
return mProvider.query(mImagesUri, null,
|
|
mImagesUrlCol + " = ?",
|
|
new String[] { url },
|
|
null);
|
|
}
|
|
|
|
public void setUp() throws Exception {
|
|
super.setUp("@ANDROID_PACKAGE_NAME@.db.BrowserProvider", "AUTHORITY");
|
|
loadContractInfo();
|
|
|
|
mTests.add(new TestSpecialFolders());
|
|
|
|
mTests.add(new TestInsertBookmarks());
|
|
mTests.add(new TestInsertBookmarksImages());
|
|
mTests.add(new TestDeleteBookmarks());
|
|
mTests.add(new TestDeleteBookmarksImages());
|
|
mTests.add(new TestUpdateBookmarks());
|
|
mTests.add(new TestUpdateBookmarksImages());
|
|
mTests.add(new TestPositionBookmarks());
|
|
|
|
mTests.add(new TestInsertHistory());
|
|
mTests.add(new TestInsertHistoryImages());
|
|
mTests.add(new TestDeleteHistory());
|
|
mTests.add(new TestDeleteHistoryImages());
|
|
mTests.add(new TestUpdateHistory());
|
|
mTests.add(new TestUpdateHistoryImages());
|
|
mTests.add(new TestUpdateOrInsertHistory());
|
|
|
|
mTests.add(new TestBatchOperations());
|
|
|
|
mTests.add(new TestCombinedView());
|
|
mTests.add(new TestCombinedViewDisplay());
|
|
mTests.add(new TestCombinedViewWithDeletedBookmark());
|
|
mTests.add(new TestCombinedViewWithDeletedReadingListItem());
|
|
mTests.add(new TestExpireHistory());
|
|
}
|
|
|
|
public void testBrowserProvider() throws Exception {
|
|
loadMobileFolderId();
|
|
|
|
for (int i = 0; i < mTests.size(); i++) {
|
|
Runnable test = mTests.get(i);
|
|
|
|
setTestName(test.getClass().getSimpleName());
|
|
ensureEmptyDatabase();
|
|
test.run();
|
|
}
|
|
}
|
|
|
|
abstract class Test implements Runnable {
|
|
public void run() {
|
|
try {
|
|
test();
|
|
} catch (Exception e) {
|
|
mAsserter.is(true, false, "Test " + this.getClass().getName() +
|
|
" threw exception: " + e);
|
|
}
|
|
}
|
|
|
|
public abstract void test() throws Exception;
|
|
}
|
|
|
|
class TestBatchOperations extends Test {
|
|
static final int TESTCOUNT = 100;
|
|
|
|
public void testApplyBatch() throws Exception {
|
|
ArrayList<ContentProviderOperation> mOperations
|
|
= new ArrayList<ContentProviderOperation>();
|
|
|
|
// Test a bunch of inserts with applyBatch
|
|
ContentValues values = new ContentValues();
|
|
ContentProviderOperation.Builder builder = null;
|
|
|
|
for (int i = 0; i < TESTCOUNT; i++) {
|
|
values.clear();
|
|
values.put(mHistoryVisitsCol, i);
|
|
values.put(mHistoryTitleCol, "Test" + i);
|
|
values.put(mHistoryUrlCol, "http://www.test.org/" + i);
|
|
|
|
// Insert
|
|
builder = ContentProviderOperation.newInsert(mHistoryUri);
|
|
builder.withValues(values);
|
|
// Queue the operation
|
|
mOperations.add(builder.build());
|
|
}
|
|
|
|
ContentProviderResult[] applyResult =
|
|
mProvider.applyBatch(mOperations);
|
|
|
|
boolean allFound = true;
|
|
for (int i = 0; i < TESTCOUNT; i++) {
|
|
Cursor cursor = mProvider.query(mHistoryUri,
|
|
null,
|
|
mHistoryUrlCol + " = ?",
|
|
new String[] { "http://www.test.org/" + i },
|
|
null);
|
|
|
|
if (!cursor.moveToFirst())
|
|
allFound = false;
|
|
cursor.close();
|
|
}
|
|
mAsserter.is(allFound, true, "Found all batchApply entries");
|
|
mOperations.clear();
|
|
|
|
// Update all visits to 1
|
|
values.clear();
|
|
values.put(mHistoryVisitsCol, 1);
|
|
for (int i = 0; i < TESTCOUNT; i++) {
|
|
builder = ContentProviderOperation.newUpdate(mHistoryUri);
|
|
builder.withSelection(mHistoryUrlCol + " = ?",
|
|
new String[] {"http://www.test.org/" + i});
|
|
builder.withValues(values);
|
|
builder.withExpectedCount(1);
|
|
// Queue the operation
|
|
mOperations.add(builder.build());
|
|
}
|
|
|
|
boolean seenException = false;
|
|
try {
|
|
applyResult = mProvider.applyBatch(mOperations);
|
|
} catch (OperationApplicationException ex) {
|
|
seenException = true;
|
|
}
|
|
mAsserter.is(seenException, false, "Batch updating succeded");
|
|
mOperations.clear();
|
|
|
|
// Delte all visits
|
|
for (int i = 0; i < TESTCOUNT; i++) {
|
|
builder = ContentProviderOperation.newDelete(mHistoryUri);
|
|
builder.withSelection(mHistoryUrlCol + " = ?",
|
|
new String[] {"http://www.test.org/" + i});
|
|
builder.withExpectedCount(1);
|
|
// Queue the operation
|
|
mOperations.add(builder.build());
|
|
}
|
|
try {
|
|
applyResult = mProvider.applyBatch(mOperations);
|
|
} catch (OperationApplicationException ex) {
|
|
seenException = true;
|
|
}
|
|
mAsserter.is(seenException, false, "Batch deletion succeded");
|
|
}
|
|
|
|
// Force a Constraint error, see if later operations still apply correctly
|
|
public void testApplyBatchErrors() {
|
|
ArrayList<ContentProviderOperation> mOperations
|
|
= new ArrayList<ContentProviderOperation>();
|
|
|
|
// Test a bunch of inserts with applyBatch
|
|
ContentValues values = new ContentValues();
|
|
ContentProviderOperation.Builder builder = null;
|
|
|
|
values.clear();
|
|
values.put(mImagesUrlCol, "http://www.test.org");
|
|
values.put(mImagesFaviconCol, "http://www.test.org/favicon.ico");
|
|
builder = ContentProviderOperation.newInsert(mImagesUri);
|
|
builder.withValues(values);
|
|
mOperations.add(builder.build());
|
|
|
|
// Make a duplicate, this will fail because of a UNIQUE constraint
|
|
builder = ContentProviderOperation.newInsert(mImagesUri);
|
|
builder.withValues(values);
|
|
mOperations.add(builder.build());
|
|
|
|
// This is valid and should be in the table afterwards
|
|
values.put(mImagesUrlCol, "http://www.test.org/valid");
|
|
builder = ContentProviderOperation.newInsert(mImagesUri);
|
|
builder.withValues(values);
|
|
mOperations.add(builder.build());
|
|
|
|
boolean seenException = false;
|
|
|
|
try {
|
|
ContentProviderResult[] applyResult =
|
|
mProvider.applyBatch(mOperations);
|
|
} catch (OperationApplicationException ex) {
|
|
seenException = true;
|
|
}
|
|
|
|
// This test may need to go away if Bug 717428 is fixed.
|
|
mAsserter.is(seenException, true, "Expected failure in images table");
|
|
|
|
boolean allFound = true;
|
|
Cursor cursor = mProvider.query(mImagesUri,
|
|
null,
|
|
mImagesUrlCol + " = ?",
|
|
new String[] { "http://www.test.org/valid" },
|
|
null);
|
|
|
|
if (!cursor.moveToFirst())
|
|
allFound = false;
|
|
cursor.close();
|
|
|
|
mAsserter.is(allFound, true, "Found all applyBatch (with error) entries");
|
|
}
|
|
|
|
public void testBulkInsert() throws Exception {
|
|
// Test a bunch of inserts with bulkInsert
|
|
ContentValues allVals[] = new ContentValues[TESTCOUNT];
|
|
for (int i = 0; i < TESTCOUNT; i++) {
|
|
allVals[i] = new ContentValues();
|
|
allVals[i].put(mHistoryUrlCol, i);
|
|
allVals[i].put(mHistoryTitleCol, "Test" + i);
|
|
allVals[i].put(mHistoryUrlCol, "http://www.test.org/" + i);
|
|
}
|
|
|
|
int inserts = mProvider.bulkInsert(mHistoryUri, allVals);
|
|
mAsserter.is(inserts, TESTCOUNT, "Excepted number of inserts matches");
|
|
|
|
boolean allFound = true;
|
|
for (int i = 0; i < TESTCOUNT; i++) {
|
|
Cursor cursor = mProvider.query(mHistoryUri,
|
|
null,
|
|
mHistoryUrlCol + " = ?",
|
|
new String[] { "http://www.test.org/" + i },
|
|
null);
|
|
|
|
if (!cursor.moveToFirst())
|
|
allFound = false;
|
|
cursor.close();
|
|
}
|
|
mAsserter.is(allFound, true, "Found all bulkInsert entries");
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
testApplyBatch();
|
|
// Clean up
|
|
ensureEmptyDatabase();
|
|
|
|
testBulkInsert();
|
|
ensureEmptyDatabase();
|
|
|
|
testApplyBatchErrors();
|
|
}
|
|
}
|
|
|
|
class TestSpecialFolders extends Test {
|
|
public void test() throws Exception {
|
|
Cursor c = mProvider.query(mBookmarksUri,
|
|
new String[] { mBookmarksIdCol,
|
|
mBookmarksGuidCol,
|
|
mBookmarksParentCol },
|
|
mBookmarksGuidCol + " = ? OR " +
|
|
mBookmarksGuidCol + " = ? OR " +
|
|
mBookmarksGuidCol + " = ? OR " +
|
|
mBookmarksGuidCol + " = ? OR " +
|
|
mBookmarksGuidCol + " = ? OR " +
|
|
mBookmarksGuidCol + " = ? OR " +
|
|
mBookmarksGuidCol + " = ?",
|
|
new String[] { PLACES_FOLDER_GUID,
|
|
MOBILE_FOLDER_GUID,
|
|
MENU_FOLDER_GUID,
|
|
TAGS_FOLDER_GUID,
|
|
TOOLBAR_FOLDER_GUID,
|
|
UNFILED_FOLDER_GUID,
|
|
READING_LIST_FOLDER_GUID },
|
|
null);
|
|
|
|
mAsserter.is(c.getCount(), 7, "Right number of special folders");
|
|
|
|
int rootId = getIntColumn("Bookmarks", "FIXED_ROOT_ID");
|
|
int readingListId = getIntColumn("Bookmarks", "FIXED_READING_LIST_ID");
|
|
|
|
while (c.moveToNext()) {
|
|
int id = c.getInt(c.getColumnIndex(mBookmarksIdCol));
|
|
String guid = c.getString(c.getColumnIndex(mBookmarksGuidCol));
|
|
int parentId = c.getInt(c.getColumnIndex(mBookmarksParentCol));
|
|
|
|
if (guid.equals(PLACES_FOLDER_GUID)) {
|
|
mAsserter.is(new Integer(id), new Integer(rootId), "The id of places folder is correct");
|
|
} else if (guid.equals(READING_LIST_FOLDER_GUID)) {
|
|
mAsserter.is(new Integer(id), new Integer(readingListId), "The id of reading list folder is correct");
|
|
}
|
|
|
|
mAsserter.is(new Integer(parentId), new Integer(rootId),
|
|
"The PARENT of the " + guid + " special folder is correct");
|
|
}
|
|
}
|
|
}
|
|
|
|
class TestInsertBookmarks extends Test {
|
|
private long insertWithNullCol(String colName) throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
b.putNull(colName);
|
|
long id = -1;
|
|
|
|
try {
|
|
id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
} catch (Exception e) {}
|
|
|
|
return id;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
long id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
Cursor c = getBookmarkById(id);
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmark found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTitleCol)), b.getAsString(mBookmarksTitleCol),
|
|
"Inserted bookmark has correct title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksUrlCol)), b.getAsString(mBookmarksUrlCol),
|
|
"Inserted bookmark has correct URL");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTagsCol)), b.getAsString(mBookmarksTagsCol),
|
|
"Inserted bookmark has correct tags");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksKeywordCol)), b.getAsString(mBookmarksKeywordCol),
|
|
"Inserted bookmark has correct keyword");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksDescriptionCol)), b.getAsString(mBookmarksDescriptionCol),
|
|
"Inserted bookmark has correct description");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksPositionCol)), b.getAsString(mBookmarksPositionCol),
|
|
"Inserted bookmark has correct position");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTypeCol)), b.getAsString(mBookmarksTypeCol),
|
|
"Inserted bookmark has correct type");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksParentCol)), b.getAsString(mBookmarksParentCol),
|
|
"Inserted bookmark has correct parent ID");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksIsDeletedCol)), String.valueOf(0),
|
|
"Inserted bookmark has correct is-deleted state");
|
|
|
|
id = insertWithNullCol(mBookmarksPositionCol);
|
|
mAsserter.is(new Long(id), new Long(-1),
|
|
"Should not be able to insert bookmark with null position");
|
|
|
|
id = insertWithNullCol(mBookmarksTypeCol);
|
|
mAsserter.is(new Long(id), new Long(-1),
|
|
"Should not be able to insert bookmark with null type");
|
|
|
|
b = createOneBookmark();
|
|
b.put(mBookmarksParentCol, -1);
|
|
id = -1;
|
|
|
|
if (Build.VERSION.SDK_INT >= 8) {
|
|
try {
|
|
id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
} catch (Exception e) {}
|
|
|
|
mAsserter.is(new Long(id), new Long(-1),
|
|
"Should not be able to insert bookmark with invalid parent");
|
|
}
|
|
|
|
b = createOneBookmark();
|
|
b.remove(mBookmarksTypeCol);
|
|
id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
c = getBookmarkById(id);
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmark found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTypeCol)), String.valueOf(mBookmarksTypeBookmark),
|
|
"Inserted bookmark has correct default type");
|
|
}
|
|
}
|
|
|
|
class TestInsertBookmarksImages extends Test {
|
|
public void test() throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
|
|
final String favicon = "FAVICON";
|
|
final String thumbnail = "THUMBNAIL";
|
|
|
|
b.put(mBookmarksFaviconCol, favicon.getBytes("UTF8"));
|
|
b.put(mBookmarksThumbnailCol, thumbnail.getBytes("UTF8"));
|
|
|
|
long id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
Cursor c = getBookmarkById(id, new String[] { mBookmarksFaviconCol, mBookmarksThumbnailCol });
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmark found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mBookmarksFaviconCol)), "UTF8"),
|
|
favicon, "Inserted bookmark has corresponding favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mBookmarksThumbnailCol)), "UTF8"),
|
|
thumbnail, "Inserted bookmark has corresponding thumbnail image");
|
|
|
|
c = getImagesByUrl(b.getAsString(mBookmarksUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted images found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesFaviconCol)), "UTF8"),
|
|
favicon, "Inserted image has corresponding favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesThumbnailCol)), "UTF8"),
|
|
thumbnail, "Inserted image has corresponding thumbnail image");
|
|
}
|
|
}
|
|
|
|
class TestDeleteBookmarks extends Test {
|
|
private long insertOneBookmark() throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
long id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
|
|
Cursor c = getBookmarkById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmark found");
|
|
|
|
return id;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
long id = insertOneBookmark();
|
|
|
|
int deleted = mProvider.delete(mBookmarksUri,
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
|
|
mAsserter.is((deleted == 1), true, "Inserted bookmark was deleted");
|
|
|
|
Cursor c = getBookmarkById(appendUriParam(mBookmarksUri, "PARAM_SHOW_DELETED", "1"), id);
|
|
mAsserter.is(c.moveToFirst(), true, "Deleted bookmark was only marked as deleted");
|
|
|
|
deleted = mProvider.delete(appendUriParam(mBookmarksUri, "PARAM_IS_SYNC", "1"),
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
|
|
mAsserter.is((deleted == 1), true, "Inserted bookmark was deleted");
|
|
|
|
c = getBookmarkById(appendUriParam(mBookmarksUri, "PARAM_SHOW_DELETED", "1"), id);
|
|
mAsserter.is(c.moveToFirst(), false, "Inserted bookmark is now actually deleted");
|
|
|
|
id = insertOneBookmark();
|
|
|
|
deleted = mProvider.delete(ContentUris.withAppendedId(mBookmarksUri, id), null, null);
|
|
mAsserter.is((deleted == 1), true,
|
|
"Inserted bookmark was deleted using URI with id");
|
|
|
|
c = getBookmarkById(id);
|
|
mAsserter.is(c.moveToFirst(), false,
|
|
"Inserted bookmark can't be found after deletion using URI with ID");
|
|
|
|
if (Build.VERSION.SDK_INT >= 8) {
|
|
ContentValues b = createBookmark("Folder", null, mMobileFolderId,
|
|
mBookmarksTypeFolder, 0, "folderTags", "folderDescription", "folderKeyword");
|
|
|
|
long parentId = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
c = getBookmarkById(parentId);
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmarks folder found");
|
|
|
|
b = createBookmark("Example", "http://example.com", parentId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
|
|
id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
c = getBookmarkById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmark found");
|
|
|
|
deleted = 0;
|
|
try {
|
|
Uri uri = ContentUris.withAppendedId(mBookmarksUri, parentId);
|
|
deleted = mProvider.delete(appendUriParam(uri, "PARAM_IS_SYNC", "1"), null, null);
|
|
} catch(Exception e) {}
|
|
|
|
mAsserter.is((deleted == 0), true,
|
|
"Should not be able to delete folder that causes orphan bookmarks");
|
|
}
|
|
}
|
|
}
|
|
|
|
class TestDeleteBookmarksImages extends Test {
|
|
public void test() throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
b.put(mBookmarksFaviconCol, new String("FAVICON").getBytes("UTF8"));
|
|
|
|
long id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
|
|
Cursor c = getImagesByUrl(b.getAsString(mBookmarksUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted images found");
|
|
|
|
mProvider.delete(ContentUris.withAppendedId(mBookmarksUri, id), null, null);
|
|
|
|
c = getImagesByUrl(b.getAsString(mBookmarksUrlCol));
|
|
mAsserter.is(c.moveToFirst(), false, "Image is deleted with last reference to it");
|
|
}
|
|
}
|
|
|
|
class TestUpdateBookmarks extends Test {
|
|
private int updateWithNullCol(long id, String colName) throws Exception {
|
|
ContentValues u = new ContentValues();
|
|
u.putNull(colName);
|
|
|
|
int updated = 0;
|
|
|
|
try {
|
|
updated = mProvider.update(mBookmarksUri, u,
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
} catch (Exception e) {}
|
|
|
|
return updated;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
long id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
|
|
Cursor c = getBookmarkById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted bookmark found");
|
|
|
|
long dateCreated = c.getLong(c.getColumnIndex(mBookmarksDateCreatedCol));
|
|
long dateModified = c.getLong(c.getColumnIndex(mBookmarksDateModifiedCol));
|
|
|
|
ContentValues u = new ContentValues();
|
|
u.put(mBookmarksTitleCol, b.getAsString(mBookmarksTitleCol) + "CHANGED");
|
|
u.put(mBookmarksUrlCol, b.getAsString(mBookmarksUrlCol) + "/more/stuff");
|
|
u.put(mBookmarksTagsCol, b.getAsString(mBookmarksTagsCol) + "CHANGED");
|
|
u.put(mBookmarksDescriptionCol, b.getAsString(mBookmarksDescriptionCol) + "CHANGED");
|
|
u.put(mBookmarksKeywordCol, b.getAsString(mBookmarksKeywordCol) + "CHANGED");
|
|
u.put(mBookmarksTypeCol, mBookmarksTypeFolder);
|
|
u.put(mBookmarksPositionCol, 10);
|
|
|
|
int updated = mProvider.update(mBookmarksUri, u,
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
|
|
mAsserter.is((updated == 1), true, "Inserted bookmark was updated");
|
|
|
|
c = getBookmarkById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Updated bookmark found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTitleCol)), u.getAsString(mBookmarksTitleCol),
|
|
"Inserted bookmark has correct title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksUrlCol)), u.getAsString(mBookmarksUrlCol),
|
|
"Inserted bookmark has correct URL");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTagsCol)), u.getAsString(mBookmarksTagsCol),
|
|
"Inserted bookmark has correct tags");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksKeywordCol)), u.getAsString(mBookmarksKeywordCol),
|
|
"Inserted bookmark has correct keyword");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksDescriptionCol)), u.getAsString(mBookmarksDescriptionCol),
|
|
"Inserted bookmark has correct description");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksPositionCol)), u.getAsString(mBookmarksPositionCol),
|
|
"Inserted bookmark has correct position");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksTypeCol)), u.getAsString(mBookmarksTypeCol),
|
|
"Inserted bookmark has correct type");
|
|
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mBookmarksDateCreatedCol))),
|
|
new Long(dateCreated),
|
|
"Updated bookmark has same creation date");
|
|
|
|
mAsserter.isnot(new Long(c.getLong(c.getColumnIndex(mBookmarksDateModifiedCol))),
|
|
new Long(dateModified),
|
|
"Updated bookmark has new modification date");
|
|
|
|
updated = updateWithNullCol(id, mBookmarksPositionCol);
|
|
mAsserter.is((updated > 0), false,
|
|
"Should not be able to update bookmark with null position");
|
|
|
|
updated = updateWithNullCol(id, mBookmarksTypeCol);
|
|
mAsserter.is((updated > 0), false,
|
|
"Should not be able to update bookmark with null type");
|
|
|
|
u = new ContentValues();
|
|
u.put(mBookmarksUrlCol, "http://examples2.com");
|
|
|
|
updated = mProvider.update(ContentUris.withAppendedId(mBookmarksUri, id), u, null, null);
|
|
|
|
c = getBookmarkById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Updated bookmark found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mBookmarksUrlCol)), u.getAsString(mBookmarksUrlCol),
|
|
"Updated bookmark has correct URL using URI with id");
|
|
}
|
|
}
|
|
|
|
class TestUpdateBookmarksImages extends Test {
|
|
public void test() throws Exception {
|
|
ContentValues b = createOneBookmark();
|
|
|
|
final String favicon = "FAVICON";
|
|
b.put(mBookmarksFaviconCol, favicon.getBytes("UTF8"));
|
|
|
|
long id = ContentUris.parseId(mProvider.insert(mBookmarksUri, b));
|
|
|
|
Cursor c = getImagesByUrl(b.getAsString(mBookmarksUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted images found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesFaviconCol)), "UTF8"),
|
|
favicon, "Inserted image has corresponding favicon image");
|
|
|
|
ContentValues u = new ContentValues();
|
|
final String newFavicon = "NEW_FAVICON";
|
|
u.put(mBookmarksFaviconCol, newFavicon.getBytes("UTF8"));
|
|
|
|
mProvider.update(ContentUris.withAppendedId(mBookmarksUri, id), u, null, null);
|
|
|
|
c = getImagesByUrl(b.getAsString(mBookmarksUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Updated images found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesFaviconCol)), "UTF8"),
|
|
newFavicon, "Updated image has corresponding favicon image");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a folder of one thousand and one bookmarks, then impose an order
|
|
* on them.
|
|
*
|
|
* Verify that the reordering worked by querying.
|
|
*/
|
|
class TestPositionBookmarks extends Test {
|
|
|
|
public String makeGUID(final long in) {
|
|
String part = String.valueOf(in);
|
|
return "aaaaaaaaaaaa".substring(0, (12 - part.length())) + part;
|
|
}
|
|
|
|
public void compareCursorToItems(final Cursor c, final String[] items, final int count) {
|
|
mAsserter.is(c.moveToFirst(), true, "Folder has children.");
|
|
|
|
int posColumn = c.getColumnIndex(mBookmarksPositionCol);
|
|
int guidColumn = c.getColumnIndex(mBookmarksGuidCol);
|
|
int i = 0;
|
|
|
|
while (!c.isAfterLast()) {
|
|
String guid = c.getString(guidColumn);
|
|
long pos = c.getLong(posColumn);
|
|
mAsserter.is(pos, (long) i, "Position matches sequence.");
|
|
mAsserter.is(guid, items[i], "GUID matches sequence.");
|
|
++i;
|
|
c.moveToNext();
|
|
}
|
|
|
|
mAsserter.is(i, count, "Folder has the right number of children.");
|
|
}
|
|
|
|
public static final int NUMBER_OF_CHILDREN = 1001;
|
|
public void test() throws Exception {
|
|
// Create the containing folder.
|
|
ContentValues folder = createBookmark("FolderFolder", "", mMobileFolderId,
|
|
mBookmarksTypeFolder, 0, "",
|
|
"description", "keyword");
|
|
folder.put(mBookmarksGuidCol, "folderfolder");
|
|
long folderId = ContentUris.parseId(mProvider.insert(mBookmarksUri, folder));
|
|
|
|
// Create the children.
|
|
String[] items = new String[NUMBER_OF_CHILDREN];
|
|
|
|
// Reuse the same ContentValues.
|
|
ContentValues item = createBookmark("Test Bookmark", "http://example.com", folderId,
|
|
mBookmarksTypeFolder, 0, "",
|
|
"description", "keyword");
|
|
|
|
for (int i = 0; i < NUMBER_OF_CHILDREN; ++i) {
|
|
String guid = makeGUID(i);
|
|
items[i] = guid;
|
|
item.put(mBookmarksGuidCol, guid);
|
|
item.put(mBookmarksPositionCol, i);
|
|
item.put(mBookmarksUrlCol, "http://example.com/" + guid);
|
|
item.put(mBookmarksTitleCol, "Test Bookmark " + guid);
|
|
mProvider.insert(mBookmarksUri, item);
|
|
}
|
|
|
|
Cursor c;
|
|
|
|
// Verify insertion.
|
|
c = getBookmarksByParent(folderId);
|
|
compareCursorToItems(c, items, NUMBER_OF_CHILDREN);
|
|
c.close();
|
|
|
|
// Now permute the items array.
|
|
Random rand = new Random();
|
|
for (int i = 0; i < NUMBER_OF_CHILDREN; ++i) {
|
|
final int newPosition = rand.nextInt(NUMBER_OF_CHILDREN);
|
|
final String switched = items[newPosition];
|
|
items[newPosition] = items[i];
|
|
items[i] = switched;
|
|
}
|
|
|
|
// Impose the positions.
|
|
long updated = mProvider.update(mBookmarksPositionUri, null, null, items);
|
|
mAsserter.is(updated, (long) NUMBER_OF_CHILDREN, "Updated " + NUMBER_OF_CHILDREN + " positions.");
|
|
|
|
// Verify that the database was updated.
|
|
c = getBookmarksByParent(folderId);
|
|
compareCursorToItems(c, items, NUMBER_OF_CHILDREN);
|
|
c.close();
|
|
}
|
|
}
|
|
|
|
class TestInsertHistory extends Test {
|
|
private long insertWithNullCol(String colName) throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
h.putNull(colName);
|
|
long id = -1;
|
|
|
|
try {
|
|
id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
} catch (Exception e) {}
|
|
|
|
return id;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
long id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
Cursor c = getHistoryEntryById(id);
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted history entry found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryTitleCol)), h.getAsString(mHistoryTitleCol),
|
|
"Inserted history entry has correct title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryUrlCol)), h.getAsString(mHistoryUrlCol),
|
|
"Inserted history entry has correct URL");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryVisitsCol)), h.getAsString(mHistoryVisitsCol),
|
|
"Inserted history entry has correct number of visits");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryLastVisitedCol)), h.getAsString(mHistoryLastVisitedCol),
|
|
"Inserted history entry has correct last visited date");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryIsDeletedCol)), String.valueOf(0),
|
|
"Inserted history entry has correct is-deleted state");
|
|
|
|
id = insertWithNullCol(mHistoryUrlCol);
|
|
mAsserter.is(new Long(id), new Long(-1),
|
|
"Should not be able to insert history with null URL");
|
|
|
|
id = insertWithNullCol(mHistoryVisitsCol);
|
|
mAsserter.is(new Long(id), new Long(-1),
|
|
"Should not be able to insert history with null number of visits");
|
|
}
|
|
}
|
|
|
|
class TestInsertHistoryImages extends Test {
|
|
public void test() throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
|
|
final String favicon = "FAVICON";
|
|
final String thumbnail = "THUMBNAIL";
|
|
|
|
h.put(mHistoryFaviconCol, favicon.getBytes("UTF8"));
|
|
h.put(mHistoryThumbnailCol, thumbnail.getBytes("UTF8"));
|
|
|
|
long id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
Cursor c = getHistoryEntryById(id, new String[] { mHistoryFaviconCol, mHistoryThumbnailCol });
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted history entry found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mHistoryFaviconCol)), "UTF8"),
|
|
favicon, "Inserted history entry has corresponding favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mHistoryThumbnailCol)), "UTF8"),
|
|
thumbnail, "Inserted history entry has corresponding thumbnail image");
|
|
|
|
c = getImagesByUrl(h.getAsString(mHistoryUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted images found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesFaviconCol)), "UTF8"),
|
|
favicon, "Inserted image has corresponding favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesThumbnailCol)), "UTF8"),
|
|
thumbnail, "Inserted image has corresponding thumbnail image");
|
|
}
|
|
}
|
|
|
|
class TestDeleteHistory extends Test {
|
|
private long insertOneHistoryEntry() throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
long id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
|
|
Cursor c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted history entry found");
|
|
|
|
return id;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
long id = insertOneHistoryEntry();
|
|
|
|
int deleted = mProvider.delete(mHistoryUri,
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
|
|
mAsserter.is((deleted == 1), true, "Inserted history entry was deleted");
|
|
|
|
Cursor c = getHistoryEntryById(appendUriParam(mHistoryUri, "PARAM_SHOW_DELETED", "1"), id);
|
|
mAsserter.is(c.moveToFirst(), true, "Deleted history entry was only marked as deleted");
|
|
|
|
deleted = mProvider.delete(appendUriParam(mHistoryUri, "PARAM_IS_SYNC", "1"),
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
|
|
mAsserter.is((deleted == 1), true, "Inserted history entry was deleted");
|
|
|
|
c = getHistoryEntryById(appendUriParam(mHistoryUri, "PARAM_SHOW_DELETED", "1"), id);
|
|
mAsserter.is(c.moveToFirst(), false, "Inserted history is now actually deleted");
|
|
|
|
id = insertOneHistoryEntry();
|
|
|
|
deleted = mProvider.delete(ContentUris.withAppendedId(mHistoryUri, id), null, null);
|
|
mAsserter.is((deleted == 1), true,
|
|
"Inserted history entry was deleted using URI with id");
|
|
|
|
c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), false,
|
|
"Inserted history entry can't be found after deletion using URI with ID");
|
|
}
|
|
}
|
|
|
|
class TestDeleteHistoryImages extends Test {
|
|
public void test() throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
h.put(mHistoryFaviconCol, new String("FAVICON").getBytes("UTF8"));
|
|
|
|
long id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
|
|
Cursor c = getImagesByUrl(h.getAsString(mHistoryUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted images found");
|
|
|
|
mProvider.delete(ContentUris.withAppendedId(mHistoryUri, id), null, null);
|
|
|
|
c = getImagesByUrl(h.getAsString(mHistoryUrlCol));
|
|
mAsserter.is(c.moveToFirst(), false, "Image is deleted with last reference to it");
|
|
}
|
|
}
|
|
|
|
class TestUpdateHistory extends Test {
|
|
private int updateWithNullCol(long id, String colName) throws Exception {
|
|
ContentValues u = new ContentValues();
|
|
u.putNull(colName);
|
|
|
|
int updated = 0;
|
|
|
|
try {
|
|
updated = mProvider.update(mHistoryUri, u,
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
} catch (Exception e) {}
|
|
|
|
return updated;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
long id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
|
|
Cursor c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted history entry found");
|
|
|
|
long dateCreated = c.getLong(c.getColumnIndex(mHistoryDateCreatedCol));
|
|
long dateModified = c.getLong(c.getColumnIndex(mHistoryDateModifiedCol));
|
|
|
|
ContentValues u = new ContentValues();
|
|
u.put(mHistoryVisitsCol, h.getAsInteger(mHistoryVisitsCol) + 1);
|
|
u.put(mHistoryLastVisitedCol, System.currentTimeMillis());
|
|
u.put(mHistoryTitleCol, h.getAsString(mHistoryTitleCol) + "CHANGED");
|
|
u.put(mHistoryUrlCol, h.getAsString(mHistoryUrlCol) + "/more/stuff");
|
|
|
|
int updated = mProvider.update(mHistoryUri, u,
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
|
|
mAsserter.is((updated == 1), true, "Inserted history entry was updated");
|
|
|
|
c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Updated history entry found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryTitleCol)), u.getAsString(mHistoryTitleCol),
|
|
"Updated history entry has correct title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryUrlCol)), u.getAsString(mHistoryUrlCol),
|
|
"Updated history entry has correct URL");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryVisitsCol)), u.getAsString(mHistoryVisitsCol),
|
|
"Updated history entry has correct number of visits");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryLastVisitedCol)), u.getAsString(mHistoryLastVisitedCol),
|
|
"Updated history entry has correct last visited date");
|
|
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryDateCreatedCol))),
|
|
new Long(dateCreated),
|
|
"Updated history entry has same creation date");
|
|
|
|
mAsserter.isnot(new Long(c.getLong(c.getColumnIndex(mHistoryDateModifiedCol))),
|
|
new Long(dateModified),
|
|
"Updated history entry has new modification date");
|
|
|
|
updated = updateWithNullCol(id, mHistoryUrlCol);
|
|
mAsserter.is((updated > 0), false,
|
|
"Should not be able to update history with null URL");
|
|
|
|
updated = updateWithNullCol(id, mHistoryVisitsCol);
|
|
mAsserter.is((updated > 0), false,
|
|
"Should not be able to update history with null number of visits");
|
|
|
|
u = new ContentValues();
|
|
u.put(mHistoryUrlCol, "http://examples2.com");
|
|
|
|
updated = mProvider.update(ContentUris.withAppendedId(mHistoryUri, id), u, null, null);
|
|
|
|
c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Updated history entry found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryUrlCol)), u.getAsString(mHistoryUrlCol),
|
|
"Updated history entry has correct URL using URI with id");
|
|
}
|
|
}
|
|
|
|
class TestUpdateHistoryImages extends Test {
|
|
public void test() throws Exception {
|
|
ContentValues h = createOneHistoryEntry();
|
|
|
|
final String favicon = "FAVICON";
|
|
h.put(mHistoryFaviconCol, favicon.getBytes("UTF8"));
|
|
|
|
long id = ContentUris.parseId(mProvider.insert(mHistoryUri, h));
|
|
|
|
Cursor c = getImagesByUrl(h.getAsString(mHistoryUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Inserted images found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesFaviconCol)), "UTF8"),
|
|
favicon, "Inserted image has corresponding favicon image");
|
|
|
|
ContentValues u = new ContentValues();
|
|
final String newFavicon = "NEW_FAVICON";
|
|
u.put(mHistoryFaviconCol, newFavicon.getBytes("UTF8"));
|
|
|
|
mProvider.update(ContentUris.withAppendedId(mHistoryUri, id), u, null, null);
|
|
|
|
c = getImagesByUrl(h.getAsString(mHistoryUrlCol));
|
|
mAsserter.is(c.moveToFirst(), true, "Updated images found");
|
|
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mImagesFaviconCol)), "UTF8"),
|
|
newFavicon, "Updated image has corresponding favicon image");
|
|
}
|
|
}
|
|
|
|
class TestUpdateOrInsertHistory extends Test {
|
|
private final String TEST_URL_1 = "http://example.com";
|
|
private final String TEST_URL_2 = "http://example.org";
|
|
private final String TEST_TITLE = "Example";
|
|
|
|
private long getHistoryEntryIdByUrl(String url) {
|
|
Cursor c = mProvider.query(mHistoryUri,
|
|
new String[] { mHistoryIdCol },
|
|
mHistoryUrlCol + " = ?",
|
|
new String[] { url },
|
|
null);
|
|
c.moveToFirst();
|
|
long id = c.getLong(0);
|
|
c.close();
|
|
|
|
return id;
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
Uri updateHistoryUriWithProfile = mHistoryUri.buildUpon().
|
|
appendQueryParameter("insert_if_needed", "true").
|
|
appendQueryParameter("increment_visits", "true").build();
|
|
|
|
// Update a non-existent history entry, without specifying visits or title
|
|
ContentValues values = new ContentValues();
|
|
values.put(mHistoryUrlCol, TEST_URL_1);
|
|
|
|
int updated = mProvider.update(updateHistoryUriWithProfile, values,
|
|
mHistoryUrlCol + " = ?",
|
|
new String[] { TEST_URL_1 });
|
|
mAsserter.is((updated == 0), true, "History entry was inserted, not updated");
|
|
|
|
long id = getHistoryEntryIdByUrl(TEST_URL_1);
|
|
Cursor c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "History entry was inserted");
|
|
|
|
long dateCreated = c.getLong(c.getColumnIndex(mHistoryDateCreatedCol));
|
|
long dateModified = c.getLong(c.getColumnIndex(mHistoryDateModifiedCol));
|
|
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryVisitsCol))), new Long(1),
|
|
"Inserted history entry has correct default number of visits");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryTitleCol)), TEST_URL_1,
|
|
"Inserted history entry has correct default title");
|
|
|
|
// Update the history entry, without specifying an additional visit count
|
|
values = new ContentValues();
|
|
values.put(mHistoryLastVisitedCol, System.currentTimeMillis());
|
|
values.put(mHistoryTitleCol, TEST_TITLE);
|
|
|
|
updated = mProvider.update(updateHistoryUriWithProfile, values,
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
mAsserter.is((updated == 1), true, "Inserted history entry was updated");
|
|
|
|
c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Updated history entry found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryTitleCol)), TEST_TITLE,
|
|
"Updated history entry has correct title");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryVisitsCol))), new Long(2),
|
|
"Updated history entry has correct number of visits");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryDateCreatedCol))), new Long(dateCreated),
|
|
"Updated history entry has same creation date");
|
|
mAsserter.isnot(new Long(c.getLong(c.getColumnIndex(mHistoryDateModifiedCol))), new Long(dateModified),
|
|
"Updated history entry has new modification date");
|
|
|
|
// Create a new history entry, specifying visits and history
|
|
values = new ContentValues();
|
|
values.put(mHistoryUrlCol, TEST_URL_2);
|
|
values.put(mHistoryTitleCol, TEST_TITLE);
|
|
values.put(mHistoryVisitsCol, 10);
|
|
|
|
updated = mProvider.update(updateHistoryUriWithProfile, values,
|
|
mHistoryUrlCol + " = ?",
|
|
new String[] { values.getAsString(mHistoryUrlCol) });
|
|
mAsserter.is((updated == 0), true, "History entry was inserted, not updated");
|
|
|
|
id = getHistoryEntryIdByUrl(TEST_URL_2);
|
|
c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "History entry was inserted");
|
|
|
|
dateCreated = c.getLong(c.getColumnIndex(mHistoryDateCreatedCol));
|
|
dateModified = c.getLong(c.getColumnIndex(mHistoryDateModifiedCol));
|
|
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryVisitsCol))), new Long(10),
|
|
"Inserted history entry has correct specified number of visits");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryTitleCol)), TEST_TITLE,
|
|
"Inserted history entry has correct specified title");
|
|
|
|
// Update the history entry, specifying additional visit count
|
|
values = new ContentValues();
|
|
values.put(mHistoryVisitsCol, 10);
|
|
|
|
updated = mProvider.update(updateHistoryUriWithProfile, values,
|
|
mHistoryIdCol + " = ?",
|
|
new String[] { String.valueOf(id) });
|
|
mAsserter.is((updated == 1), true, "Inserted history entry was updated");
|
|
|
|
c = getHistoryEntryById(id);
|
|
mAsserter.is(c.moveToFirst(), true, "Updated history entry found");
|
|
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryTitleCol)), TEST_TITLE,
|
|
"Updated history entry has correct unchanged title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mHistoryUrlCol)), TEST_URL_2,
|
|
"Updated history entry has correct unchanged URL");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryVisitsCol))), new Long(20),
|
|
"Updated history entry has correct number of visits");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mHistoryDateCreatedCol))), new Long(dateCreated),
|
|
"Updated history entry has same creation date");
|
|
mAsserter.isnot(new Long(c.getLong(c.getColumnIndex(mHistoryDateModifiedCol))), new Long(dateModified),
|
|
"Updated history entry has new modification date");
|
|
|
|
}
|
|
}
|
|
|
|
class TestCombinedView extends Test {
|
|
public void test() throws Exception {
|
|
final String TITLE_1 = "Test Page 1";
|
|
final String TITLE_2 = "Test Page 2";
|
|
final String TITLE_3_HISTORY = "Test Page 3 (History Entry)";
|
|
final String TITLE_3_BOOKMARK = "Test Page 3 (Bookmark Entry)";
|
|
final String TITLE_3_BOOKMARK2 = "Test Page 3 (Bookmark Entry 2)";
|
|
|
|
final String URL_1 = "http://example1.com";
|
|
final String URL_2 = "http://example2.com";
|
|
final String URL_3 = "http://example3.com";
|
|
|
|
final String HISTORY_FAVICON = "HISTORY_FAVICON";
|
|
final String HISTORY_THUMBNAIL = "HISTORY_THUMBNAIL";
|
|
final String BOOKMARK_FAVICON = "BOOKMARK_FAVICON";
|
|
final String BOOKMARK_THUMBNAIL = "BOOKMARK_THUMBNAIL";
|
|
|
|
final int VISITS = 10;
|
|
final long LAST_VISITED = System.currentTimeMillis();
|
|
|
|
// Create a basic history entry with images
|
|
ContentValues basicHistory = createHistoryEntry(TITLE_1, URL_1, VISITS, LAST_VISITED);
|
|
basicHistory.put(mHistoryFaviconCol, HISTORY_FAVICON.getBytes("UTF8"));
|
|
basicHistory.put(mHistoryThumbnailCol, HISTORY_THUMBNAIL.getBytes("UTF8"));
|
|
long basicHistoryId = ContentUris.parseId(mProvider.insert(mHistoryUri, basicHistory));
|
|
|
|
// Create a basic bookmark entry with images
|
|
ContentValues basicBookmark = createBookmark(TITLE_2, URL_2, mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
basicBookmark.put(mBookmarksFaviconCol, BOOKMARK_FAVICON.getBytes("UTF8"));
|
|
basicBookmark.put(mBookmarksThumbnailCol, BOOKMARK_THUMBNAIL.getBytes("UTF8"));
|
|
long basicBookmarkId = ContentUris.parseId(mProvider.insert(mBookmarksUri, basicBookmark));
|
|
|
|
// Create a history entry and bookmark entry with the same URL to
|
|
// represent a visited bookmark
|
|
ContentValues combinedHistory = createHistoryEntry(TITLE_3_HISTORY, URL_3, VISITS, LAST_VISITED);
|
|
combinedHistory.put(mHistoryFaviconCol, HISTORY_FAVICON.getBytes("UTF8"));
|
|
combinedHistory.put(mHistoryThumbnailCol, HISTORY_THUMBNAIL.getBytes("UTF8"));
|
|
long combinedHistoryId = ContentUris.parseId(mProvider.insert(mHistoryUri, combinedHistory));
|
|
|
|
|
|
ContentValues combinedBookmark = createBookmark(TITLE_3_BOOKMARK, URL_3, mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
combinedBookmark.put(mBookmarksFaviconCol, BOOKMARK_FAVICON.getBytes("UTF8"));
|
|
combinedBookmark.put(mBookmarksThumbnailCol, BOOKMARK_THUMBNAIL.getBytes("UTF8"));
|
|
long combinedBookmarkId = ContentUris.parseId(mProvider.insert(mBookmarksUri, combinedBookmark));
|
|
|
|
ContentValues combinedBookmark2 = createBookmark(TITLE_3_BOOKMARK2, URL_3, mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
combinedBookmark2.put(mBookmarksFaviconCol, BOOKMARK_FAVICON.getBytes("UTF8"));
|
|
combinedBookmark2.put(mBookmarksThumbnailCol, BOOKMARK_THUMBNAIL.getBytes("UTF8"));
|
|
long combinedBookmarkId2 = ContentUris.parseId(mProvider.insert(mBookmarksUri, combinedBookmark2));
|
|
|
|
// Create a bookmark folder to make sure it _doesn't_ show up in the results
|
|
ContentValues folderBookmark = createBookmark("", "", mMobileFolderId,
|
|
mBookmarksTypeFolder, 0, "tags", "description", "keyword");
|
|
mProvider.insert(mBookmarksUri, folderBookmark);
|
|
|
|
// Sort entries by url so we can check them individually
|
|
Cursor c = mProvider.query(mCombinedUri, null, "", null, mCombinedUrlCol);
|
|
|
|
mAsserter.is(c.getCount(), 3, "3 combined entries found");
|
|
|
|
// First combined entry is basic history entry
|
|
mAsserter.is(c.moveToFirst(), true, "Found basic history entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedIdCol))), new Long(0),
|
|
"Combined _id column should always be 0");
|
|
// TODO: Should we change BrowserProvider to make this return -1, not 0?
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol))), new Long(0),
|
|
"Bookmark id should be 0 for basic history entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedHistoryIdCol))), new Long(basicHistoryId),
|
|
"Basic history entry has correct history id");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mCombinedTitleCol)), TITLE_1,
|
|
"Basic history entry has correct title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mCombinedUrlCol)), URL_1,
|
|
"Basic history entry has correct url");
|
|
mAsserter.is(c.getInt(c.getColumnIndex(mCombinedVisitsCol)), VISITS,
|
|
"Basic history entry has correct number of visits");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedLastVisitedCol))), new Long(LAST_VISITED),
|
|
"Basic history entry has correct last visit time");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mCombinedFaviconCol)), "UTF8"),
|
|
HISTORY_FAVICON, "Basic history entry has corresponding favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mCombinedThumbnailCol)), "UTF8"),
|
|
HISTORY_THUMBNAIL, "Basic history entry has corresponding thumbnail image");
|
|
|
|
// Second combined entry is basic bookmark entry
|
|
mAsserter.is(c.moveToNext(), true, "Found basic bookmark entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedIdCol))), new Long(0),
|
|
"Combined _id column should always be 0");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol))), new Long(basicBookmarkId),
|
|
"Basic bookmark entry has correct bookmark id");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedHistoryIdCol))), new Long(-1),
|
|
"History id should be -1 for basic bookmark entry");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mCombinedTitleCol)), TITLE_2,
|
|
"Basic bookmark entry has correct title");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mCombinedUrlCol)), URL_2,
|
|
"Basic bookmark entry has correct url");
|
|
mAsserter.is(c.getInt(c.getColumnIndex(mCombinedVisitsCol)), -1,
|
|
"Visits should be -1 for basic bookmark entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedLastVisitedCol))), new Long(-1),
|
|
"Last visited should be -1 for basic bookmark entry");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mCombinedFaviconCol)), "UTF8"),
|
|
BOOKMARK_FAVICON, "Basic bookmark entry has corresponding favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mCombinedThumbnailCol)), "UTF8"),
|
|
BOOKMARK_THUMBNAIL, "Basic bookmark entry has corresponding thumbnail image");
|
|
|
|
// Third combined entry is a combined history/bookmark entry
|
|
mAsserter.is(c.moveToNext(), true, "Found third combined entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedIdCol))), new Long(0),
|
|
"Combined _id column should always be 0");
|
|
// The bookmark data (bookmark_id and title) associated with the combined entry is non-deterministic,
|
|
// it might end up with data coming from any of the matching bookmark entries.
|
|
mAsserter.is(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol)) == combinedBookmarkId ||
|
|
c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol)) == combinedBookmarkId2, true,
|
|
"Combined entry has correct bookmark id");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mCombinedTitleCol)).equals(TITLE_3_BOOKMARK) ||
|
|
c.getString(c.getColumnIndex(mCombinedTitleCol)).equals(TITLE_3_BOOKMARK2), true,
|
|
"Combined entry has title corresponding to bookmark entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedHistoryIdCol))), new Long(combinedHistoryId),
|
|
"Combined entry has correct history id");
|
|
mAsserter.is(c.getString(c.getColumnIndex(mCombinedUrlCol)), URL_3,
|
|
"Combined entry has correct url");
|
|
mAsserter.is(c.getInt(c.getColumnIndex(mCombinedVisitsCol)), VISITS,
|
|
"Combined entry has correct number of visits");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedLastVisitedCol))), new Long(LAST_VISITED),
|
|
"Combined entry has correct last visit time");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mCombinedFaviconCol)), "UTF8"),
|
|
BOOKMARK_FAVICON, "Combined entry has bookmark favicon image");
|
|
mAsserter.is(new String(c.getBlob(c.getColumnIndex(mCombinedThumbnailCol)), "UTF8"),
|
|
BOOKMARK_THUMBNAIL, "Combined entry has bookmark thumbnail image");
|
|
}
|
|
}
|
|
|
|
class TestCombinedViewDisplay extends Test {
|
|
public void test() throws Exception {
|
|
final String TITLE_1 = "Test Page 1";
|
|
final String TITLE_2 = "Test Page 2";
|
|
final String TITLE_3_HISTORY = "Test Page 3 (History Entry)";
|
|
final String TITLE_3_BOOKMARK = "Test Page 3 (Bookmark Entry)";
|
|
final String TITLE_4 = "Test Page 4";
|
|
|
|
final String URL_1 = "http://example.com";
|
|
final String URL_2 = "http://example.org";
|
|
final String URL_3 = "http://examples2.com";
|
|
final String URL_4 = "http://readinglist.com";
|
|
|
|
final int VISITS = 10;
|
|
final long LAST_VISITED = System.currentTimeMillis();
|
|
|
|
// Create a basic history entry
|
|
ContentValues basicHistory = createHistoryEntry(TITLE_1, URL_1, VISITS, LAST_VISITED);
|
|
ContentUris.parseId(mProvider.insert(mHistoryUri, basicHistory));
|
|
|
|
// Create a basic bookmark entry
|
|
ContentValues basicBookmark = createBookmark(TITLE_2, URL_2, mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
mProvider.insert(mBookmarksUri, basicBookmark);
|
|
|
|
// Create a history entry and bookmark entry with the same URL to
|
|
// represent a visited bookmark
|
|
ContentValues combinedHistory = createHistoryEntry(TITLE_3_HISTORY, URL_3, VISITS, LAST_VISITED);
|
|
mProvider.insert(mHistoryUri, combinedHistory);
|
|
|
|
ContentValues combinedBookmark = createBookmark(TITLE_3_BOOKMARK, URL_3, mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
mProvider.insert(mBookmarksUri, combinedBookmark);
|
|
|
|
// Create a reading list entries
|
|
int readingListId = getIntColumn("Bookmarks", "FIXED_READING_LIST_ID");
|
|
ContentValues readingListItem = createBookmark(TITLE_3_BOOKMARK, URL_3, readingListId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
long readingListItemId = ContentUris.parseId(mProvider.insert(mBookmarksUri, readingListItem));
|
|
|
|
ContentValues readingListItem2 = createBookmark(TITLE_4, URL_4, readingListId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
long readingListItemId2 = ContentUris.parseId(mProvider.insert(mBookmarksUri, readingListItem2));
|
|
|
|
Cursor c = mProvider.query(mCombinedUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 4, "4 combined entries found");
|
|
|
|
while (c.moveToNext()) {
|
|
long id = c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol));
|
|
|
|
int display = c.getInt(c.getColumnIndex(mCombinedDisplayCol));
|
|
int expectedDisplay = (id == readingListItemId || id == readingListItemId2 ? mCombinedDisplayReader : mCombinedDisplayNormal);
|
|
|
|
mAsserter.is(new Integer(display), new Integer(expectedDisplay),
|
|
"Combined display column should always be DISPLAY_READER for the reading list item");
|
|
}
|
|
}
|
|
}
|
|
|
|
class TestCombinedViewWithDeletedBookmark extends Test {
|
|
public void test() throws Exception {
|
|
final String TITLE = "Test Page 1";
|
|
final String URL = "http://example.com";
|
|
final int VISITS = 10;
|
|
final long LAST_VISITED = System.currentTimeMillis();
|
|
|
|
// Create a combined history entry
|
|
ContentValues combinedHistory = createHistoryEntry(TITLE, URL, VISITS, LAST_VISITED);
|
|
mProvider.insert(mHistoryUri, combinedHistory);
|
|
|
|
// Create a combined bookmark entry
|
|
ContentValues combinedBookmark = createBookmark(TITLE, URL, mMobileFolderId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
long combinedBookmarkId = ContentUris.parseId(mProvider.insert(mBookmarksUri, combinedBookmark));
|
|
|
|
Cursor c = mProvider.query(mCombinedUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 1, "1 combined entry found");
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Found combined entry with bookmark id");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol))), new Long(combinedBookmarkId),
|
|
"Bookmark id should be set correctly on combined entry");
|
|
|
|
int deleted = mProvider.delete(mBookmarksUri,
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(combinedBookmarkId) });
|
|
|
|
mAsserter.is((deleted == 1), true, "Inserted combined bookmark was deleted");
|
|
|
|
c = mProvider.query(mCombinedUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 1, "1 combined entry found");
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Found combined entry without bookmark id");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol))), new Long(0),
|
|
"Bookmark id should not be set to removed bookmark id");
|
|
}
|
|
}
|
|
|
|
class TestCombinedViewWithDeletedReadingListItem extends Test {
|
|
public void test() throws Exception {
|
|
final String TITLE = "Test Page 1";
|
|
final String URL = "http://example.com";
|
|
final int VISITS = 10;
|
|
final long LAST_VISITED = System.currentTimeMillis();
|
|
|
|
// Create a combined history entry
|
|
ContentValues combinedHistory = createHistoryEntry(TITLE, URL, VISITS, LAST_VISITED);
|
|
mProvider.insert(mHistoryUri, combinedHistory);
|
|
|
|
// Create a combined bookmark entry
|
|
int readingListId = getIntColumn("Bookmarks", "FIXED_READING_LIST_ID");
|
|
ContentValues combinedReadingListItem = createBookmark(TITLE, URL, readingListId,
|
|
mBookmarksTypeBookmark, 0, "tags", "description", "keyword");
|
|
long combinedReadingListItemId = ContentUris.parseId(mProvider.insert(mBookmarksUri, combinedReadingListItem));
|
|
|
|
Cursor c = mProvider.query(mCombinedUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 1, "1 combined entry found");
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Found combined entry with bookmark id");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol))), new Long(combinedReadingListItemId),
|
|
"Bookmark id should be set correctly on combined entry");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedDisplayCol))), new Long(mCombinedDisplayReader),
|
|
"Combined entry should have reader display type");
|
|
|
|
int deleted = mProvider.delete(mBookmarksUri,
|
|
mBookmarksIdCol + " = ?",
|
|
new String[] { String.valueOf(combinedReadingListItemId) });
|
|
|
|
mAsserter.is((deleted == 1), true, "Inserted combined reading list item was deleted");
|
|
|
|
c = mProvider.query(mCombinedUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 1, "1 combined entry found");
|
|
|
|
mAsserter.is(c.moveToFirst(), true, "Found combined entry without bookmark id");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedBookmarkIdCol))), new Long(0),
|
|
"Bookmark id should not be set to removed bookmark id");
|
|
mAsserter.is(new Long(c.getLong(c.getColumnIndex(mCombinedDisplayCol))), new Long(mCombinedDisplayNormal),
|
|
"Combined entry should have reader display type");
|
|
}
|
|
}
|
|
|
|
class TestExpireHistory extends Test {
|
|
private void createFakeHistory(long timeShift, int count) {
|
|
// Insert a bunch of very new entries
|
|
ContentValues allVals[] = new ContentValues[count];
|
|
long time = System.currentTimeMillis() - timeShift;
|
|
for (int i = 0; i < count; i++) {
|
|
allVals[i] = new ContentValues();
|
|
allVals[i].put(mHistoryTitleCol, "Test " + i);
|
|
allVals[i].put(mHistoryUrlCol, "http://www.test.org/" + i);
|
|
allVals[i].put(mHistoryVisitsCol, i);
|
|
allVals[i].put(mHistoryLastVisitedCol, time);
|
|
}
|
|
|
|
int inserts = mProvider.bulkInsert(mHistoryUri, allVals);
|
|
mAsserter.is(inserts, count, "Excepted number of inserts matches");
|
|
|
|
// inserting a new entry sets the date created and modified automatically
|
|
// reset all of them
|
|
for (int i = 0; i < count; i++) {
|
|
ContentValues cv = new ContentValues();
|
|
cv.put(mHistoryDateCreatedCol, time);
|
|
cv.put(mHistoryDateModifiedCol, time);
|
|
mProvider.update(mHistoryUri, cv, mHistoryUrlCol + " = ?",
|
|
new String[] { "http://www.test.org/" + i });
|
|
}
|
|
|
|
Cursor c = mProvider.query(mHistoryUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), count, count + " history entries found");
|
|
}
|
|
|
|
public void test() throws Exception {
|
|
final int count = 3000;
|
|
|
|
// insert a bunch of new entries
|
|
createFakeHistory(0, count);
|
|
|
|
// expiring with a normal priority should not delete new entries
|
|
Uri url = appendUriParam(mHistoryOldUri, "PARAM_EXPIRE_PRIORITY", "NORMAL");
|
|
mProvider.delete(url, null, null);
|
|
Cursor c = mProvider.query(mHistoryUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), count, count + " history entries found");
|
|
|
|
// expiring with a aggressive priority should leave 500 entries
|
|
url = appendUriParam(mHistoryOldUri, "PARAM_EXPIRE_PRIORITY", "AGGRESSIVE");
|
|
mProvider.delete(url, null, null);
|
|
c = mProvider.query(mHistoryUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 500, "500 history entries found");
|
|
|
|
ensureEmptyDatabase();
|
|
|
|
// insert a bunch of entries with an old time created/modified
|
|
long time = 1000L * 60L * 60L * 24L * 30L * 3L;
|
|
createFakeHistory(time, count);
|
|
|
|
// expiring with an normal priority should remove at most 1000 entries
|
|
// entries leaving at least 2000
|
|
url = appendUriParam(mHistoryOldUri, "PARAM_EXPIRE_PRIORITY", "NORMAL");
|
|
mProvider.delete(url, null, null);
|
|
c = mProvider.query(mHistoryUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 2000, "2000 history entries found");
|
|
|
|
// expiring with an agressive priority should remove old
|
|
// entries leaving at least 500
|
|
url = appendUriParam(mHistoryOldUri, "PARAM_EXPIRE_PRIORITY", "AGGRESSIVE");
|
|
mProvider.delete(url, null, null);
|
|
c = mProvider.query(mHistoryUri, null, "", null, null);
|
|
mAsserter.is(c.getCount(), 500, "500 history entries found");
|
|
}
|
|
}
|
|
}
|