/*
* 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 com.android.vcard.tests.testutils;
import android.content.ContentResolver;
import android.content.EntityIterator;
import android.database.Cursor;
import android.net.Uri;
import android.test.AndroidTestCase;
import android.test.mock.MockContext;
import android.text.TextUtils;
import android.util.Log;
import com.android.vcard.VCardComposer;
import com.android.vcard.VCardConfig;
import com.android.vcard.VCardEntryConstructor;
import com.android.vcard.VCardParser;
import com.android.vcard.VCardUtils;
import com.android.vcard.exception.VCardException;
import junit.framework.TestCase;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
/**
* <p>
* The class lets users checks that given expected vCard data are same as given actual vCard data.
* Able to verify both vCard importer/exporter.
* </p>
* <p>
* First a user has to initialize the object by calling either
* {@link #initForImportTest(int, int)} or {@link #initForExportTest(int)}.
* "Round trip test" (import -> export -> import, or export -> import -> export) is not supported.
* </p>
*/
public class VCardVerifier {
private static final String LOG_TAG = "VCardVerifier";
private static final boolean DEBUG = true;
/**
* Special URI for testing.
*/
/* package */ static final String VCARD_TEST_AUTHORITY = "com.android.unit_tests.vcard";
private static final Uri VCARD_TEST_AUTHORITY_URI =
Uri.parse("content://" + VCARD_TEST_AUTHORITY);
/* package */ static final Uri CONTACTS_TEST_CONTENT_URI =
Uri.withAppendedPath(VCARD_TEST_AUTHORITY_URI, "contacts");
private static class CustomMockContext extends MockContext {
final ContentResolver mResolver;
public CustomMockContext(ContentResolver resolver) {
mResolver = resolver;
}
@Override
public ContentResolver getContentResolver() {
return mResolver;
}
}
private final AndroidTestCase mAndroidTestCase;
private int mVCardType;
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;
private String mCharset;
private String mExceptionContents;
// Called by VCardTestsBase
public VCardVerifier(AndroidTestCase androidTestCase) {
mAndroidTestCase = androidTestCase;
mExportTestResolver = null;
mInputStream = null;
mInitialized = false;
mVerified = false;
}
// Should be called at the beginning of each import test.
public void initForImportTest(int vcardType, int resId) {
if (mInitialized) {
AndroidTestCase.fail("Already initialized");
}
mVCardType = vcardType;
mIsDoCoMo = VCardConfig.isDoCoMo(vcardType);
setInputResourceId(resId);
mInitialized = true;
}
// Should be called at the beginning of each export test.
public void initForExportTest(int vcardType) {
initForExportTest(vcardType, "UTF-8");
}
public void initForExportTest(int vcardType, String charset) {
if (mInitialized) {
AndroidTestCase.fail("Already initialized");
}
mExportTestResolver = new ExportTestResolver(mAndroidTestCase);
mVCardType = vcardType;
mIsDoCoMo = VCardConfig.isDoCoMo(vcardType);
mInitialized = true;
if (TextUtils.isEmpty(charset)) {
mCharset = "UTF-8";
} else {
mCharset = charset;
}
}
private void setInputResourceId(int resId) {
final InputStream inputStream =
mAndroidTestCase.getContext().getResources().openRawResource(resId);
if (inputStream == null) {
AndroidTestCase.fail("Wrong resId: " + resId);
}
setInputStream(inputStream);
}
private void setInputStream(InputStream inputStream) {
if (mExportTestResolver != null) {
AndroidTestCase.fail("addInputEntry() is called.");
} else if (mInputStream != null) {
AndroidTestCase.fail("InputStream is already set");
}
mInputStream = inputStream;
}
public ContactEntry addInputEntry() {
if (!mInitialized) {
AndroidTestCase.fail("Not initialized");
}
if (mInputStream != null) {
AndroidTestCase.fail("setInputStream is called");
}
return mExportTestResolver.addInputContactEntry();
}
public PropertyNodesVerifierElem addPropertyNodesVerifierElemWithoutVersion() {
if (!mInitialized) {
AndroidTestCase.fail("Not initialized");
}
if (mPropertyNodesVerifier == null) {
mPropertyNodesVerifier = new PropertyNodesVerifier(mAndroidTestCase);
}
return mPropertyNodesVerifier.addPropertyNodesVerifierElem();
}
public PropertyNodesVerifierElem addPropertyNodesVerifierElem() {
final PropertyNodesVerifierElem elem = addPropertyNodesVerifierElemWithoutVersion();
final String versionString;
if (VCardConfig.isVersion21(mVCardType)) {
versionString = "2.1";
} else if (VCardConfig.isVersion30(mVCardType)) {
versionString = "3.0";
} else if (VCardConfig.isVersion40(mVCardType)) {
versionString = "4.0";
} else {
throw new RuntimeException("Unexpected vcard type during a unit test");
}
elem.addExpectedNodeWithOrder("VERSION", versionString);
return elem;
}
public PropertyNodesVerifierElem addPropertyNodesVerifierElemWithEmptyName() {
if (!mInitialized) {
AndroidTestCase.fail("Not initialized");
}
final PropertyNodesVerifierElem elem = addPropertyNodesVerifierElem();
if (VCardConfig.isVersion40(mVCardType)) {
elem.addExpectedNodeWithOrder("FN", "");
} else if (VCardConfig.isVersion30(mVCardType)) {
elem.addExpectedNodeWithOrder("N", "");
elem.addExpectedNodeWithOrder("FN", "");
} else if (mIsDoCoMo) {
elem.addExpectedNodeWithOrder("N", "");
}
return elem;
}
public LineVerifierElem addLineVerifierElem() {
if (!mInitialized) {
AndroidTestCase.fail("Not initialized");
}
if (mLineVerifier == null) {
mLineVerifier = new LineVerifier(mAndroidTestCase, mVCardType);
}
return mLineVerifier.addLineVerifierElem();
}
public ContentValuesVerifierElem addContentValuesVerifierElem() {
if (!mInitialized) {
AndroidTestCase.fail("Not initialized");
}
if (mContentValuesVerifier == null) {
mContentValuesVerifier = new ContentValuesVerifier();
}
return mContentValuesVerifier.addElem(mAndroidTestCase);
}
public void addVCardExceptionVerifier(String contents) {
mExceptionContents = contents;
}
/**
* Sets up sub-verifiers correctly and tries to parse vCard as {@link InputStream}.
* Errors around InputStream must be handled outside this method.
*
* Used both from {@link #verifyForImportTest()} and from {@link #verifyForExportTest()}.
*/
private void verifyWithInputStream(InputStream is) throws IOException {
try {
// Note: we must not specify charset toward vCard parsers. This code checks whether
// those parsers are able to encode given binary without any extra information for
// charset.
final VCardParser parser = VCardUtils.getAppropriateParser(mVCardType);
if (mContentValuesVerifier != null) {
final VCardEntryConstructor constructor = new VCardEntryConstructor(mVCardType);
constructor.addEntryHandler(mContentValuesVerifier);
parser.addInterpreter(constructor);
}
if (mPropertyNodesVerifier != null) {
parser.addInterpreter(mPropertyNodesVerifier);
}
parser.parse(is);
if (mExceptionContents != null) {
// exception contents exists, we expect an exception to occur.
AndroidTestCase.fail();
}
} catch (VCardException e) {
if (mExceptionContents != null) {
AndroidTestCase.assertTrue(e.getMessage().contains(mExceptionContents));
} else {
Log.e(LOG_TAG, "VCardException", e);
AndroidTestCase.fail("Unexpected VCardException: " + e.getMessage());
}
}
}
private void verifyOneVCardForExport(final String vcard) {
if (DEBUG) Log.d(LOG_TAG, vcard);
InputStream is = null;
try {
is = new ByteArrayInputStream(vcard.getBytes(mCharset));
verifyWithInputStream(is);
} catch (IOException e) {
AndroidTestCase.fail("Unexpected IOException: " + e.getMessage());
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
AndroidTestCase.fail("Unexpected IOException: " + e.getMessage());
}
}
}
}
public void verify() {
if (!mInitialized) {
TestCase.fail("Not initialized.");
}
if (mVerified) {
TestCase.fail("verify() was called twice.");
}
if (mInputStream != null) {
if (mExportTestResolver != null){
TestCase.fail("There are two input sources.");
}
verifyForImportTest();
} else if (mExportTestResolver != null){
verifyForExportTest();
} else {
TestCase.fail("No input is determined");
}
mVerified = true;
}
private void verifyForImportTest() {
if (mLineVerifier != null) {
AndroidTestCase.fail("Not supported now.");
}
try {
verifyWithInputStream(mInputStream);
} catch (IOException e) {
AndroidTestCase.fail("IOException was thrown: " + e.getMessage());
} finally {
if (mInputStream != null) {
try {
mInputStream.close();
} catch (IOException e) {
}
}
}
}
public static EntityIterator mockGetEntityIteratorMethod(
final ContentResolver resolver,
final Uri uri, final String selection,
final String[] selectionArgs, final String sortOrder) {
if (ExportTestResolver.class.equals(resolver.getClass())) {
return ((ExportTestResolver)resolver).getProvider().queryEntities(
uri, selection, selectionArgs, sortOrder);
}
Log.e(LOG_TAG, "Unexpected provider given.");
return null;
}
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 CustomMockContext context = new CustomMockContext(mExportTestResolver);
final ContentResolver resolver = context.getContentResolver();
final VCardComposer composer = new VCardComposer(context, mVCardType, mCharset);
// projection is ignored.
final Cursor cursor = resolver.query(CONTACTS_TEST_CONTENT_URI, null, null, null, null);
if (!composer.init(cursor)) {
AndroidTestCase.fail("init() failed. Reason: " + composer.getErrorReason());
}
AndroidTestCase.assertFalse(composer.isAfterLast());
try {
while (!composer.isAfterLast()) {
Method mockGetEntityIteratorMethod = null;
try {
mockGetEntityIteratorMethod = getMockGetEntityIteratorMethod();
} catch (Exception e) {
AndroidTestCase.fail("Exception thrown: " + e);
}
AndroidTestCase.assertNotNull(mockGetEntityIteratorMethod);
final String vcard = composer.createOneEntry(mockGetEntityIteratorMethod);
AndroidTestCase.assertNotNull(vcard);
if (mLineVerifier != null) {
mLineVerifier.verify(vcard);
}
verifyOneVCardForExport(vcard);
}
} finally {
composer.terminate();
}
}
}