326 lines
13 KiB
Java
326 lines
13 KiB
Java
/**
|
|
* Copyright (c) 2015, The CyanogenMod 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 org.cyanogenmod.cmsettings.tests;
|
|
|
|
import android.content.ContentResolver;
|
|
import android.content.ContentValues;
|
|
import android.content.Context;
|
|
import android.content.IContentProvider;
|
|
import android.content.pm.UserInfo;
|
|
import android.database.Cursor;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.RemoteException;
|
|
import android.os.UserHandle;
|
|
import android.os.UserManager;
|
|
import android.provider.Settings;
|
|
import android.test.AndroidTestCase;
|
|
import android.test.suitebuilder.annotation.MediumTest;
|
|
import android.test.suitebuilder.annotation.SmallTest;
|
|
import android.text.TextUtils;
|
|
import cyanogenmod.providers.CMSettings;
|
|
import org.cyanogenmod.cmsettings.CMSettingsProvider;
|
|
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
|
|
public class CMSettingsProviderTest extends AndroidTestCase {
|
|
private static final String TAG = "CMSettingsProviderTest";
|
|
|
|
private static final LinkedHashMap<String, String> sMap = new LinkedHashMap<String, String>();
|
|
|
|
static {
|
|
sMap.put("testKey1", "value1");
|
|
sMap.put("testKey2", "value2");
|
|
sMap.put("testKey3", "value3");
|
|
}
|
|
|
|
private static final String[] PROJECTIONS = new String[] { Settings.NameValueTable.NAME,
|
|
Settings.NameValueTable.VALUE };
|
|
|
|
private ContentResolver mContentResolver;
|
|
private UserManager mUserManager;
|
|
private UserInfo mGuest;
|
|
|
|
@Override
|
|
public void setUp() {
|
|
mContentResolver = mContext.getContentResolver();
|
|
mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
|
|
}
|
|
|
|
@Override
|
|
public void tearDown() {
|
|
if (mGuest != null) {
|
|
mUserManager.removeUser(mGuest.id);
|
|
}
|
|
}
|
|
|
|
@MediumTest
|
|
public void testMigrateCMSettingsForOtherUser() {
|
|
// Make sure there's an owner
|
|
assertTrue(findUser(mUserManager, UserHandle.USER_OWNER));
|
|
|
|
mGuest = mUserManager.createGuest(mContext, "GuestUser1");
|
|
assertNotNull(mGuest);
|
|
|
|
testMigrateSettingsForUser(mGuest.id);
|
|
}
|
|
|
|
/**
|
|
* make sure that queries to SettingsProvider are forwarded to CMSettingsProvider as needed
|
|
* See {@link cyanogenmod.providers.CMSettings.System#shouldInterceptSystemProvider(String)}
|
|
*
|
|
* Currently this test only checks that
|
|
* {@link cyanogenmod.providers.CMSettings.System#SYSTEM_PROFILES_ENABLED} is expected to
|
|
* be forwarded, and is forwarded.
|
|
*/
|
|
@SmallTest
|
|
public void testSettingsProviderKeyForwarding() {
|
|
String forwardedKey = CMSettings.System.SYSTEM_PROFILES_ENABLED;
|
|
|
|
// make sure the key should be forwarded
|
|
assertTrue(CMSettings.System.shouldInterceptSystemProvider(forwardedKey));
|
|
|
|
// put value 1 into Settings provider:
|
|
// let's try to disable the profiles via the Settings provider
|
|
Settings.System.putStringForUser(mContentResolver,
|
|
forwardedKey, "0", UserHandle.USER_CURRENT);
|
|
|
|
// assert this is what we just put in there
|
|
assertEquals("0", Settings.System.getStringForUser(getContext().getContentResolver(),
|
|
forwardedKey, UserHandle.USER_CURRENT));
|
|
|
|
// put value 2 into CMSettings provider
|
|
CMSettings.System.putStringForUser(mContentResolver,
|
|
forwardedKey, "1", UserHandle.USER_CURRENT);
|
|
|
|
assertEquals("1", CMSettings.System.getStringForUser(getContext().getContentResolver(),
|
|
forwardedKey, UserHandle.USER_CURRENT));
|
|
|
|
// assert reading from both returns value 2
|
|
final String cmProviderValue = CMSettings.System.getStringForUser(
|
|
getContext().getContentResolver(), forwardedKey, UserHandle.USER_CURRENT);
|
|
final String settingsProviderValue = Settings.System.getStringForUser(
|
|
getContext().getContentResolver(), forwardedKey, UserHandle.USER_CURRENT);
|
|
assertEquals(cmProviderValue, settingsProviderValue);
|
|
}
|
|
|
|
/**
|
|
* The new {@link CMSettings.Secure#CM_SETUP_WIZARD_COMPLETED} cm specific provisioned flag
|
|
* should be equal to the old {@link Settings.Global#DEVICE_PROVISIONED} flag on boot, or on
|
|
* upgrade. These flags will almost always be equal, except during the provisioning process,
|
|
* they may change at slightly different times.
|
|
*
|
|
* Test whether the setting was properly set and is not null.
|
|
*
|
|
* @deprecated Replaced by {@link Settings.Global#DEVICE_PROVISIONED}
|
|
* or {@link Settings.Secure#USER_SETUP_COMPLETE}
|
|
*/
|
|
@Deprecated
|
|
@SmallTest
|
|
public void testCMProvisionedFlagFallbackSet() {
|
|
final String newCmFlag = CMSettings.Secure.getStringForUser(
|
|
getContext().getContentResolver(), CMSettings.Secure.CM_SETUP_WIZARD_COMPLETED,
|
|
UserHandle.USER_OWNER);
|
|
assertNotNull(newCmFlag);
|
|
|
|
final String previousFlag = Settings.Global.getStringForUser(
|
|
getContext().getContentResolver(), Settings.Global.DEVICE_PROVISIONED,
|
|
UserHandle.USER_OWNER);
|
|
assertEquals(previousFlag, newCmFlag);
|
|
}
|
|
|
|
private void testMigrateSettingsForUser(int userId) {
|
|
// Setup values in Settings
|
|
/*final String expectedPullDownValue = "testQuickPullDownValue";
|
|
Settings.System.putStringForUser(mContentResolver,
|
|
CMSettingsProvider.LegacyCMSettings.STATUS_BAR_QUICK_QS_PULLDOWN,
|
|
expectedPullDownValue, userId);
|
|
|
|
final int expectedKeyboardBrightness = 4;
|
|
Settings.Secure.putIntForUser(mContentResolver,
|
|
CMSettingsProvider.LegacyCMSettings.KEYBOARD_BRIGHTNESS,
|
|
expectedKeyboardBrightness, userId);
|
|
|
|
Bundle arg = new Bundle();
|
|
arg.putInt(CMSettings.CALL_METHOD_USER_KEY, userId);
|
|
IContentProvider contentProvider = mContentResolver.acquireProvider(
|
|
CMSettings.AUTHORITY);
|
|
|
|
try{
|
|
// Trigger migrate settings for guest
|
|
contentProvider.call(mContentResolver.getPackageName(),
|
|
CMSettings.CALL_METHOD_MIGRATE_SETTINGS_FOR_USER, null, arg);
|
|
} catch (RemoteException ex) {
|
|
fail("Failed to trigger settings migration due to RemoteException");
|
|
}
|
|
|
|
// Check values
|
|
final String actualPullDownValue = CMSettings.System.getStringForUser(mContentResolver,
|
|
CMSettings.System.QS_QUICK_PULLDOWN, userId);
|
|
assertEquals(expectedPullDownValue, actualPullDownValue);
|
|
|
|
final int actualKeyboardBrightness = CMSettings.Secure.getIntForUser(mContentResolver,
|
|
CMSettings.Secure.KEYBOARD_BRIGHTNESS, -1, userId);
|
|
assertEquals(expectedKeyboardBrightness, actualKeyboardBrightness);*/
|
|
}
|
|
|
|
private boolean findUser(UserManager userManager, int userHandle) {
|
|
for (UserInfo user : userManager.getUsers()) {
|
|
if (user.id == userHandle) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@MediumTest
|
|
public void testBulkInsertSuccess() {
|
|
ContentValues[] contentValues = new ContentValues[sMap.size()];
|
|
String[] keyValues = new String[sMap.size()];
|
|
int count = 0;
|
|
for (Map.Entry<String, String> kVPair : sMap.entrySet()) {
|
|
ContentValues contentValue = new ContentValues();
|
|
|
|
final String key = kVPair.getKey();
|
|
contentValue.put(Settings.NameValueTable.NAME, key);
|
|
keyValues[count] = key;
|
|
|
|
contentValue.put(Settings.NameValueTable.VALUE, kVPair.getValue());
|
|
contentValues[count++] = contentValue;
|
|
}
|
|
|
|
testBulkInsertForUri(CMSettings.System.CONTENT_URI, contentValues, keyValues);
|
|
testBulkInsertForUri(CMSettings.Secure.CONTENT_URI, contentValues, keyValues);
|
|
testBulkInsertForUri(CMSettings.Global.CONTENT_URI, contentValues, keyValues);
|
|
}
|
|
|
|
private void testBulkInsertForUri(Uri uri, ContentValues[] contentValues, String[] keyValues) {
|
|
int rowsInserted = mContentResolver.bulkInsert(uri, contentValues);
|
|
assertEquals(sMap.size(), rowsInserted);
|
|
|
|
final String placeholderSymbol = "?";
|
|
String[] placeholders = new String[contentValues.length];
|
|
for (int i = 0; i < placeholders.length; i++) {
|
|
placeholders[i] = placeholderSymbol;
|
|
}
|
|
|
|
final String placeholdersString = TextUtils.join(",", placeholders);
|
|
|
|
Cursor queryCursor = mContentResolver.query(uri, PROJECTIONS,
|
|
Settings.NameValueTable.NAME + " IN (" + placeholdersString + ")", keyValues,
|
|
null);
|
|
assertEquals(contentValues.length, queryCursor.getCount());
|
|
try {
|
|
while (queryCursor.moveToNext()) {
|
|
assertEquals(PROJECTIONS.length, queryCursor.getColumnCount());
|
|
|
|
String actualKey = queryCursor.getString(0);
|
|
assertTrue(sMap.containsKey(actualKey));
|
|
|
|
assertEquals(sMap.get(actualKey), queryCursor.getString(1));
|
|
}
|
|
}
|
|
finally {
|
|
queryCursor.close();
|
|
}
|
|
|
|
// TODO: Find a better way to cleanup database/use ProviderTestCase2 without process crash
|
|
for (String key : sMap.keySet()) {
|
|
mContentResolver.delete(uri, Settings.NameValueTable.NAME + " = ?",
|
|
new String[]{ key });
|
|
}
|
|
}
|
|
|
|
@MediumTest
|
|
public void testInsertUpdateDeleteSuccess() {
|
|
//testInsertUpdateDeleteForUri(CMSettings.System.CONTENT_URI);
|
|
testInsertUpdateDeleteForUri(CMSettings.Secure.CONTENT_URI);
|
|
testInsertUpdateDeleteForUri(CMSettings.Global.CONTENT_URI);
|
|
}
|
|
|
|
private void testInsertUpdateDeleteForUri(Uri uri) {
|
|
String key = "key";
|
|
String value1 = "value1";
|
|
String value2 = "value2";
|
|
|
|
// test insert
|
|
ContentValues contentValue = new ContentValues();
|
|
contentValue.put(Settings.NameValueTable.NAME, key);
|
|
contentValue.put(Settings.NameValueTable.VALUE, value1);
|
|
|
|
Uri expectedUri = uri.withAppendedPath(uri, key);
|
|
Uri returnUri = mContentResolver.insert(uri, contentValue);
|
|
assertEquals(expectedUri, returnUri);
|
|
|
|
Cursor queryCursor = null;
|
|
try {
|
|
// check insert
|
|
queryCursor = mContentResolver.query(uri, PROJECTIONS, Settings.NameValueTable.NAME +
|
|
" = ?", new String[]{ key }, null);
|
|
assertEquals(1, queryCursor.getCount());
|
|
|
|
assertExpectedKeyValuePair(queryCursor, key, value1);
|
|
|
|
// check insert with returned uri
|
|
queryCursor = mContentResolver.query(returnUri, PROJECTIONS, null, null, null);
|
|
assertEquals(1, queryCursor.getCount());
|
|
|
|
assertExpectedKeyValuePair(queryCursor, key, value1);
|
|
|
|
// test update
|
|
contentValue.clear();
|
|
contentValue.put(Settings.NameValueTable.VALUE, value2);
|
|
|
|
int rowsAffected = mContentResolver.update(uri, contentValue,
|
|
Settings.NameValueTable.NAME + " = ?", new String[]{ key });
|
|
assertEquals(1, rowsAffected);
|
|
|
|
// check update
|
|
queryCursor = mContentResolver.query(uri, PROJECTIONS, Settings.NameValueTable.NAME +
|
|
" = ?", new String[]{ key }, null);
|
|
assertEquals(1, queryCursor.getCount());
|
|
|
|
assertExpectedKeyValuePair(queryCursor, key, value2);
|
|
|
|
// test delete
|
|
rowsAffected = mContentResolver.delete(uri, Settings.NameValueTable.NAME + " = ?",
|
|
new String[]{ key });
|
|
assertEquals(1, rowsAffected);
|
|
|
|
// check delete
|
|
queryCursor = mContentResolver.query(uri, PROJECTIONS, Settings.NameValueTable.NAME +
|
|
" = ?", new String[]{ key }, null);
|
|
assertEquals(0, queryCursor.getCount());
|
|
} finally {
|
|
if (queryCursor != null) {
|
|
queryCursor.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void assertExpectedKeyValuePair(Cursor cursor, String expectedKey,
|
|
String expectedValue) {
|
|
cursor.moveToNext();
|
|
assertEquals(PROJECTIONS.length, cursor.getColumnCount());
|
|
|
|
String actualKey = cursor.getString(0);
|
|
assertEquals(expectedKey, actualKey);
|
|
assertEquals(expectedValue, cursor.getString(1));
|
|
}
|
|
}
|