/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package android.pim.vcard;
import android.content.ContentProvider;
import android.content.ContentResolver;
import android.content.Context;
import android.content.EntityIterator;
import android.net.Uri;
import android.pim.vcard.VCardComposer;
import android.pim.vcard.VCardConfig;
import android.pim.vcard.VCardEntryConstructor;
import android.pim.vcard.VCardInterpreter;
import android.pim.vcard.VCardInterpreterCollection;
import android.pim.vcard.VCardParser;
import android.pim.vcard.VCardParser_V21;
import android.pim.vcard.VCardParser_V30;
import android.pim.vcard.exception.VCardException;
import android.test.AndroidTestCase;
import android.test.mock.MockContext;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Arrays;
/* package */ class CustomMockContext extends MockContext {
final ContentResolver mResolver;
public CustomMockContext(ContentResolver resolver) {
mResolver = resolver;
}
@Override
public ContentResolver getContentResolver() {
return mResolver;
}
}
/* package */ class VCardVerifier {
private class VCardVerifierInternal implements VCardComposer.OneEntryHandler {
public boolean onInit(Context context) {
return true;
}
public boolean onEntryCreated(String vcard) {
verifyOneVCard(vcard);
return true;
}
public void onTerminate() {
}
}
private final AndroidTestCase mTestCase;
private final VCardVerifierInternal mVCardVerifierInternal;
private int mVCardType;
private boolean mIsV30;
private boolean mIsDoCoMo;
// Only one of them must be non-empty.
private ExportTestResolver mExportTestResolver;
private InputStream mInputStream;
// To allow duplication, use list instead of set.
// When null, we don't need to do the verification.
private PropertyNodesVerifier mPropertyNodesVerifier;
private LineVerifier mLineVerifier;
private ContentValuesVerifier mContentValuesVerifier;
private boolean mInitialized;
private boolean mVerified = false;
public VCardVerifier(AndroidTestCase androidTestCase) {
mTestCase = androidTestCase;
mVCardVerifierInternal = new VCardVerifierInternal();
mExportTestResolver = null;
mInputStream = null;
mInitialized = false;
mVerified = false;
}
public void initForExportTest(int vcardType) {
if (mInitialized) {
mTestCase.fail("Already initialized");
}
mExportTestResolver = new ExportTestResolver(mTestCase);
mVCardType = vcardType;
mIsV30 = VCardConfig.isV30(vcardType);
mIsDoCoMo = VCardConfig.isDoCoMo(vcardType);
mInitialized = true;
}
public void initForImportTest(int vcardType, int resId) {
if (mInitialized) {
mTestCase.fail("Already initialized");
}
mVCardType = vcardType;
mIsV30 = VCardConfig.isV30(vcardType);
mIsDoCoMo = VCardConfig.isDoCoMo(vcardType);
setInputResourceId(resId);
mInitialized = true;
}
private void setInputResourceId(int resId) {
InputStream inputStream = mTestCase.getContext().getResources().openRawResource(resId);
if (inputStream == null) {
mTestCase.fail("Wrong resId: " + resId);
}
setInputStream(inputStream);
}
private void setInputStream(InputStream inputStream) {
if (mExportTestResolver != null) {
mTestCase.fail("addInputEntry() is called.");
} else if (mInputStream != null) {
mTestCase.fail("InputStream is already set");
}
mInputStream = inputStream;
}
public ContactEntry addInputEntry() {
if (!mInitialized) {
mTestCase.fail("Not initialized");
}
if (mInputStream != null) {
mTestCase.fail("setInputStream is called");
}
return mExportTestResolver.addInputContactEntry();
}
public PropertyNodesVerifierElem addPropertyNodesVerifierElem() {
if (!mInitialized) {
mTestCase.fail("Not initialized");
}
if (mPropertyNodesVerifier == null) {
mPropertyNodesVerifier = new PropertyNodesVerifier(mTestCase);
}
PropertyNodesVerifierElem elem =
mPropertyNodesVerifier.addPropertyNodesVerifierElem();
elem.addExpectedNodeWithOrder("VERSION", (mIsV30 ? "3.0" : "2.1"));
return elem;
}
public PropertyNodesVerifierElem addPropertyNodesVerifierElemWithEmptyName() {
if (!mInitialized) {
mTestCase.fail("Not initialized");
}
PropertyNodesVerifierElem elem = addPropertyNodesVerifierElem();
if (mIsV30) {
elem.addExpectedNodeWithOrder("N", "").addExpectedNodeWithOrder("FN", "");
} else if (mIsDoCoMo) {
elem.addExpectedNodeWithOrder("N", "");
}
return elem;
}
public LineVerifierElem addLineVerifierElem() {
if (!mInitialized) {
mTestCase.fail("Not initialized");
}
if (mLineVerifier == null) {
mLineVerifier = new LineVerifier(mTestCase, mVCardType);
}
return mLineVerifier.addLineVerifierElem();
}
public ContentValuesVerifierElem addContentValuesVerifierElem() {
if (!mInitialized) {
mTestCase.fail("Not initialized");
}
if (mContentValuesVerifier == null) {
mContentValuesVerifier = new ContentValuesVerifier();
}
return mContentValuesVerifier.addElem(mTestCase);
}
private void verifyOneVCard(final String vcard) {
// Log.d("@@@", vcard);
final VCardInterpreter builder;
if (mContentValuesVerifier != null) {
final VNodeBuilder vnodeBuilder = mPropertyNodesVerifier;
final VCardEntryConstructor vcardDataBuilder =
new VCardEntryConstructor(mVCardType);
vcardDataBuilder.addEntryHandler(mContentValuesVerifier);
if (mPropertyNodesVerifier != null) {
builder = new VCardInterpreterCollection(Arrays.asList(
mPropertyNodesVerifier, vcardDataBuilder));
} else {
builder = vnodeBuilder;
}
} else {
if (mPropertyNodesVerifier != null) {
builder = mPropertyNodesVerifier;
} else {
return;
}
}
final VCardParser parser =
(mIsV30 ? new VCardParser_V30(true) : new VCardParser_V21());
InputStream is = null;
try {
String charset =
(VCardConfig.usesShiftJis(mVCardType) ? "SHIFT_JIS" : "UTF-8");
is = new ByteArrayInputStream(vcard.getBytes(charset));
mTestCase.assertEquals(true, parser.parse(is, null, builder));
} catch (IOException e) {
mTestCase.fail("Unexpected IOException: " + e.getMessage());
} catch (VCardException e) {
mTestCase.fail("Unexpected VCardException: " + e.getMessage());
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
}
}
}
}
public void verify() {
if (!mInitialized) {
mTestCase.fail("Not initialized.");
}
if (mVerified) {
mTestCase.fail("verify() was called twice.");
}
if (mInputStream != null) {
try {
verifyForImportTest();
} catch (IOException e) {
mTestCase.fail("IOException was thrown: " + e.getMessage());
} catch (VCardException e) {
mTestCase.fail("VCardException was thrown: " + e.getMessage());
}
} else if (mExportTestResolver != null){
verifyForExportTest();
} else {
mTestCase.fail("No input is determined");
}
mVerified = true;
}
private void verifyForImportTest() throws IOException, VCardException {
if (mLineVerifier != null) {
mTestCase.fail("Not supported now.");
}
if (mContentValuesVerifier != null) {
mContentValuesVerifier.verify(mInputStream, mVCardType);
}
}
public static EntityIterator mockGetEntityIteratorMethod(
final ContentResolver resolver,
final Uri uri, final String selection,
final String[] selectionArgs, final String sortOrder) {
final ContentProvider provider =
resolver.acquireContentProviderClient(uri).getLocalContentProvider();
return ((ExportTestProvider)provider).queryEntities(
uri, selection, selectionArgs, sortOrder);
}
private Method getMockGetEntityIteratorMethod()
throws SecurityException, NoSuchMethodException {
return this.getClass().getMethod("mockGetEntityIteratorMethod",
ContentResolver.class, Uri.class, String.class, String[].class, String.class);
}
private void verifyForExportTest() {
final VCardComposer composer =
new VCardComposer(new CustomMockContext(mExportTestResolver), mVCardType);
composer.addHandler(mLineVerifier);
composer.addHandler(mVCardVerifierInternal);
if (!composer.init(VCardComposer.CONTACTS_TEST_CONTENT_URI, null, null, null)) {
mTestCase.fail("init() failed. Reason: " + composer.getErrorReason());
}
mTestCase.assertFalse(composer.isAfterLast());
try {
while (!composer.isAfterLast()) {
try {
final Method mockGetEntityIteratorMethod = getMockGetEntityIteratorMethod();
mTestCase.assertTrue(
composer.createOneEntry(getMockGetEntityIteratorMethod()));
} catch (Exception e) {
e.printStackTrace();
mTestCase.fail();
}
}
} finally {
composer.terminate();
}
}
}