Merge change I27b1bb90 into eclair-mr2

/*

 * 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

/*

 * 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

/*

 * 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