Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 673c1d1f authored by Daisuke Miyakawa's avatar Daisuke Miyakawa
Browse files

Refactor vCard test code and modify unit tests. 

Factor out all the classes previously embedded in VCardTestsBase.java so that readers are able to
look over each file easily and each class explicitly mention the dependency between each other.

Make all the test cases use mVerifier in VCardTestsBase so that verify() call will not be
forgotten. Actually there were three tests found in which verify() was not called.

Internal issue number: 2195990
parent eb114de5

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() {

    }

}