Merge change I27b1bb90 into eclair-mr2 (4f81eac4) · Commits · e / os / android_frameworks_base

tests/AndroidTests/src/com/android/unit_tests/vcard/ContentValuesVerifier.java

0 → 100644

+101 −0

Original line number	Diff line number	Diff line
		/*
		* 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.unit_tests.vcard;

		import android.pim.vcard.VCardConfig;
		import android.pim.vcard.VCardEntry;
		import android.pim.vcard.VCardEntryConstructor;
		import android.pim.vcard.VCardEntryHandler;
		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 java.io.IOException;
		import java.io.InputStream;
		import java.util.ArrayList;
		import java.util.List;

		/* package */ class ContentValuesVerifier implements VCardEntryHandler {
		private AndroidTestCase mTestCase;
		private List<ContentValuesVerifierElem> mContentValuesVerifierElemList =
		new ArrayList<ContentValuesVerifierElem>();
		private int mIndex;

		public ContentValuesVerifierElem addElem(AndroidTestCase androidTestCase) {
		mTestCase = androidTestCase;
		ContentValuesVerifierElem importVerifier = new ContentValuesVerifierElem(androidTestCase);
		mContentValuesVerifierElemList.add(importVerifier);
		return importVerifier;
		}

		public void verify(int resId, int vCardType) throws IOException, VCardException {
		verify(mTestCase.getContext().getResources().openRawResource(resId), vCardType);
		}

		public void verify(int resId, int vCardType, final VCardParser vCardParser)
		throws IOException, VCardException {
		verify(mTestCase.getContext().getResources().openRawResource(resId),
		vCardType, vCardParser);
		}

		public void verify(InputStream is, int vCardType) throws IOException, VCardException {
		final VCardParser vCardParser;
		if (VCardConfig.isV30(vCardType)) {
		vCardParser = new VCardParser_V30(true); // use StrictParsing
		} else {
		vCardParser = new VCardParser_V21();
		}
		verify(is, vCardType, vCardParser);
		}

		public void verify(InputStream is, int vCardType, final VCardParser vCardParser)
		throws IOException, VCardException {
		VCardEntryConstructor builder =
		new VCardEntryConstructor(null, null, false, vCardType, null);
		builder.addEntryHandler(this);
		try {
		vCardParser.parse(is, builder);
		} finally {
		if (is != null) {
		try {
		is.close();
		} catch (IOException e) {
		}
		}
		}
		}

		public void onStart() {
		for (ContentValuesVerifierElem elem : mContentValuesVerifierElemList) {
		elem.onParsingStart();
		}
		}

		public void onEntryCreated(VCardEntry entry) {
		mTestCase.assertTrue(mIndex < mContentValuesVerifierElemList.size());
		mContentValuesVerifierElemList.get(mIndex).onEntryCreated(entry);
		mIndex++;
		}

		public void onEnd() {
		for (ContentValuesVerifierElem elem : mContentValuesVerifierElemList) {
		elem.onParsingEnd();
		elem.verifyResolver();
		}
		}
		}
		No newline at end of file

tests/AndroidTests/src/com/android/unit_tests/vcard/ContentValuesVerifierElem.java

0 → 100644

+95 −0

Original line number	Diff line number	Diff line
		/*
		* 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.unit_tests.vcard;

		import android.content.ContentValues;
		import android.pim.vcard.VCardConfig;
		import android.pim.vcard.VCardEntry;
		import android.pim.vcard.VCardEntryCommitter;
		import android.pim.vcard.VCardEntryConstructor;
		import android.pim.vcard.VCardEntryHandler;
		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.provider.ContactsContract.Data;
		import android.test.AndroidTestCase;

		import java.io.IOException;
		import java.io.InputStream;

		/* package */ class ContentValuesVerifierElem {
		private final AndroidTestCase mTestCase;
		private final ImportTestResolver mResolver;
		private final VCardEntryHandler mHandler;

		public ContentValuesVerifierElem(AndroidTestCase androidTestCase) {
		mTestCase = androidTestCase;
		mResolver = new ImportTestResolver(androidTestCase);
		mHandler = new VCardEntryCommitter(mResolver);
		}

		public ContentValuesBuilder addExpected(String mimeType) {
		ContentValues contentValues = new ContentValues();
		contentValues.put(Data.MIMETYPE, mimeType);
		mResolver.addExpectedContentValues(contentValues);
		return new ContentValuesBuilder(contentValues);
		}

		public void verify(int resId, int vCardType)
		throws IOException, VCardException {
		verify(mTestCase.getContext().getResources().openRawResource(resId), vCardType);
		}

		public void verify(InputStream is, int vCardType) throws IOException, VCardException {
		final VCardParser vCardParser;
		if (VCardConfig.isV30(vCardType)) {
		vCardParser = new VCardParser_V30(true); // use StrictParsing
		} else {
		vCardParser = new VCardParser_V21();
		}
		VCardEntryConstructor builder =
		new VCardEntryConstructor(null, null, false, vCardType, null);
		builder.addEntryHandler(mHandler);
		try {
		vCardParser.parse(is, builder);
		} finally {
		if (is != null) {
		try {
		is.close();
		} catch (IOException e) {
		}
		}
		}
		verifyResolver();
		}

		public void verifyResolver() {
		mResolver.verify();
		}

		public void onParsingStart() {
		mHandler.onStart();
		}

		public void onEntryCreated(VCardEntry entry) {
		mHandler.onEntryCreated(entry);
		}

		public void onParsingEnd() {
		mHandler.onEnd();
		}
		}
		No newline at end of file

tests/AndroidTests/src/com/android/unit_tests/vcard/ExportTestResolver.java

0 → 100644

+195 −0

Original line number	Diff line number	Diff line
		/*
		* 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.unit_tests.vcard;

		import android.content.ContentResolver;
		import android.content.ContentValues;
		import android.content.Entity;
		import android.content.EntityIterator;
		import android.database.Cursor;
		import android.net.Uri;
		import android.pim.vcard.VCardComposer;
		import android.provider.ContactsContract.Contacts;
		import android.provider.ContactsContract.Data;
		import android.provider.ContactsContract.RawContacts;
		import android.test.mock.MockContentResolver;
		import android.test.mock.MockCursor;

		import junit.framework.TestCase;

		import java.util.ArrayList;
		import java.util.Iterator;
		import java.util.List;

		/* package */ public class ExportTestResolver extends MockContentResolver {
		ExportTestProvider mProvider;
		public ExportTestResolver(TestCase testCase) {
		mProvider = new ExportTestProvider(testCase);
		addProvider(VCardComposer.VCARD_TEST_AUTHORITY, mProvider);
		addProvider(RawContacts.CONTENT_URI.getAuthority(), mProvider);
		}

		public ContactEntry addInputContactEntry() {
		return mProvider.buildInputEntry();
		}
		}

		/* package */ class MockEntityIterator implements EntityIterator {
		List<Entity> mEntityList;
		Iterator<Entity> mIterator;

		public MockEntityIterator(List<ContentValues> contentValuesList) {
		mEntityList = new ArrayList<Entity>();
		Entity entity = new Entity(new ContentValues());
		for (ContentValues contentValues : contentValuesList) {
		entity.addSubValue(Data.CONTENT_URI, contentValues);
		}
		mEntityList.add(entity);
		mIterator = mEntityList.iterator();
		}

		public boolean hasNext() {
		return mIterator.hasNext();
		}

		public Entity next() {
		return mIterator.next();
		}

		public void reset() {
		mIterator = mEntityList.iterator();
		}

		public void close() {
		}
		}

		/**
		* Represents one contact, which should contain multiple ContentValues like
		* StructuredName, Email, etc.
		*/
		/* package */ class ContactEntry {
		private final List<ContentValues> mContentValuesList = new ArrayList<ContentValues>();

		public ContentValuesBuilder addContentValues(String mimeType) {
		ContentValues contentValues = new ContentValues();
		contentValues.put(Data.MIMETYPE, mimeType);
		mContentValuesList.add(contentValues);
		return new ContentValuesBuilder(contentValues);
		}

		public List<ContentValues> getList() {
		return mContentValuesList;
		}
		}

		/* package */ class ExportTestProvider extends MockContentProvider {
		final private TestCase mTestCase;
		final private ArrayList<ContactEntry> mContactEntryList = new ArrayList<ContactEntry>();

		public ExportTestProvider(TestCase testCase) {
		mTestCase = testCase;
		}

		public ContactEntry buildInputEntry() {
		ContactEntry contactEntry = new ContactEntry();
		mContactEntryList.add(contactEntry);
		return contactEntry;
		}

		@Override
		public EntityIterator queryEntities(Uri uri, String selection, String[] selectionArgs,
		String sortOrder) {
		mTestCase.assertTrue(uri != null);
		mTestCase.assertTrue(ContentResolver.SCHEME_CONTENT.equals(uri.getScheme()));
		final String authority = uri.getAuthority();
		mTestCase.assertTrue(RawContacts.CONTENT_URI.getAuthority().equals(authority));
		mTestCase.assertTrue((Data.CONTACT_ID + "=?").equals(selection));
		mTestCase.assertEquals(1, selectionArgs.length);
		int id = Integer.parseInt(selectionArgs[0]);
		mTestCase.assertTrue(id >= 0 && id < mContactEntryList.size());

		return new MockEntityIterator(mContactEntryList.get(id).getList());
		}

		@Override
		public Cursor query(Uri uri, String[] projection,
		String selection, String[] selectionArgs, String sortOrder) {
		mTestCase.assertTrue(VCardComposer.CONTACTS_TEST_CONTENT_URI.equals(uri));
		// In this test, following arguments are not supported.
		mTestCase.assertNull(selection);
		mTestCase.assertNull(selectionArgs);
		mTestCase.assertNull(sortOrder);

		return new MockCursor() {
		int mCurrentPosition = -1;

		@Override
		public int getCount() {
		return mContactEntryList.size();
		}

		@Override
		public boolean moveToFirst() {
		mCurrentPosition = 0;
		return true;
		}

		@Override
		public boolean moveToNext() {
		if (mCurrentPosition < mContactEntryList.size()) {
		mCurrentPosition++;
		return true;
		} else {
		return false;
		}
		}

		@Override
		public boolean isBeforeFirst() {
		return mCurrentPosition < 0;
		}

		@Override
		public boolean isAfterLast() {
		return mCurrentPosition >= mContactEntryList.size();
		}

		@Override
		public int getColumnIndex(String columnName) {
		mTestCase.assertEquals(Contacts._ID, columnName);
		return 0;
		}

		@Override
		public int getInt(int columnIndex) {
		mTestCase.assertEquals(0, columnIndex);
		mTestCase.assertTrue(mCurrentPosition >= 0
		&& mCurrentPosition < mContactEntryList.size());
		return mCurrentPosition;
		}

		@Override
		public String getString(int columnIndex) {
		return String.valueOf(getInt(columnIndex));
		}

		@Override
		public void close() {
		}
		};
		}
		}
		No newline at end of file

tests/AndroidTests/src/com/android/unit_tests/vcard/ImportTestResolver.java

0 → 100644

+299 −0

File added.

Preview size limit exceeded, changes collapsed.

tests/AndroidTests/src/com/android/unit_tests/vcard/LineVerifier.java

0 → 100644

+65 −0

Original line number	Diff line number	Diff line
		/*
		* 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.unit_tests.vcard;

		import android.content.Context;
		import android.pim.vcard.VCardComposer;

		import junit.framework.TestCase;

		import java.util.ArrayList;

		class LineVerifier implements VCardComposer.OneEntryHandler {
		private final TestCase mTestCase;
		private final ArrayList<LineVerifierElem> mLineVerifierElemList;
		private int mVCardType;
		private int index;

		public LineVerifier(TestCase testCase, int vcardType) {
		mTestCase = testCase;
		mLineVerifierElemList = new ArrayList<LineVerifierElem>();
		mVCardType = vcardType;
		}

		public LineVerifierElem addLineVerifierElem() {
		LineVerifierElem lineVerifier = new LineVerifierElem(mTestCase, mVCardType);
		mLineVerifierElemList.add(lineVerifier);
		return lineVerifier;
		}

		public void verify(String vcard) {
		if (index >= mLineVerifierElemList.size()) {
		mTestCase.fail("Insufficient number of LineVerifier (" + index + ")");
		}

		LineVerifierElem lineVerifier = mLineVerifierElemList.get(index);
		lineVerifier.verify(vcard);

		index++;
		}

		public boolean onEntryCreated(String vcard) {
		verify(vcard);
		return true;
		}

		public boolean onInit(Context context) {
		return true;
		}

		public void onTerminate() {
		}
		}