/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.mj.test.rms;

import j2meunit.framework.Test;

import j2meunit.framework.TestCase;

import j2meunit.framework.TestMethod;

import j2meunit.framework.TestSuite;

import javax.microedition.rms.*;

/* These tests are made with knowledge about record store internal implementation.

 */

public class RecordStoreTest extends TestCase

{

    public RecordStoreTest() {}

    public RecordStoreTest(String sTestName, TestMethod rTestMethod)

    {

        super(sTestName, rTestMethod);

    }

    public Test suite()

    {

        TestSuite aSuite = new TestSuite();

        aSuite.addTest(new RecordStoreTest("testOpenRecordStore", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testOpenRecordStore();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testUsingSharedRecordStore", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testUsingSharedRecordStore();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testGetCommonProperties", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testGetCommonProperties();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testCompareProperties", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testCompareProperties();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testAddRecord", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testAddRecord();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testAddDeleteRecords", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testAddDeleteRecords();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testAddDeleteRecords2", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testAddDeleteRecords2();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testGetSize", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testGetSize();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testGetNextRecordId", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testGetNextRecordId();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testNullRecord", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testNullRecord();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testListRecordstore", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testListRecordstore();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testEnumeration", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testEnumeration();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testListeners", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testListeners();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testFiltering", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testFiltering();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testSplitAndMerge", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testSplitAndMerge();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testRecordStoreSpeed", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testRecordStoreSpeed();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testEnumerationWithEmptyStore", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testEnumerationWithEmptyStore();

            }

        }));

        aSuite.addTest(new RecordStoreTest("testFilterComparator", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((RecordStoreTest) tc).testFilterComparator();

            }

        }));

        return aSuite;

    }

    public void assertEquals(byte[] a, byte[] b)

    {

        assertEquals(a.length, b.length);

        for (int i = 0; i < a.length; i++)

        {

            assertEquals(a[i], b[i]);

        }

    }

    public void testOpenRecordStore()

    {

        System.out.println("RecordStoreTest.testOpenRecordStore()");

        RecordStore store = null;

        // 1: IllegalArgumentException

        System.out.println("1: IllegalArgumentException - zero length name");

        try

        {

            store = RecordStore.openRecordStore("", true);

            fail("IllegalArgumentException for zero lenght rs name was not thrown");

        }

        catch (IllegalArgumentException iae)

        {

            //test OK

        }

        catch (Exception e)

        {

            fail("Wrong exception " + e);

        }

        System.out.println("1: IllegalArgumentException - too long name");

        try

        {

            store = RecordStore.openRecordStore("aaaaabbbbbcccccdddddeeeeefffffggg", true);

            fail("IllegalArgumentException for 33 chars lenght rs name expected");

        }

        catch (IllegalArgumentException iae)

        {

            //test OK

        }

        catch (Exception e)

        {

            fail("Wrong exception " + e);

        }

        // 2: RecordStoreNotFoundException

        System.out.println("2: RecordStoreNotFoundException");

        try

        {

            store = RecordStore.openRecordStore("no_such_rs", false);

            fail("RecordStoreNotFoundException expected");

        }

        catch (RecordStoreNotFoundException nfe)

        {

            //test OK

        }

        catch (Exception e)

        {

            fail("Wrong exception " + e);

        }

        //3: create new record store

        System.out.println("3: create new record store");

        try

        {

            store = RecordStore.openRecordStore("new_rs", true);

            assertNotNull(store);

        }

        catch (Exception e)

        {

            fail("Exception not expected " + e);

        }

        //4: open record store one more time

        System.out.println("4: open record store one more time");

        try

        {

            RecordStore store2 = RecordStore.openRecordStore("new_rs", false);

            if (!store2.equals(store))

            {

                fail("reference was not to the same RecordStore object ");

            }

            store2.closeRecordStore();

        }

        catch (Exception e)

        {

            fail("Exception not expected " + e);

        }

        //5: open existing record store

        System.out.println("5: open existing record store");

        try

        {

            store.closeRecordStore(); //was open in 1.3

            store = RecordStore.openRecordStore("new_rs", false);

            assertNotNull(store);

        }

        catch (Exception e)

        {

            fail("Exception not expected " + e);

        }

        //6: clean up

        System.out.println("6: clean up");

        try

        {

            store.closeRecordStore();

            RecordStore.deleteRecordStore("new_rs");

        }

        catch (Exception e)

        {

            fail("Exception not expected " + e);

        }

        //7: close record store second time

        System.out.println("7: close record store second time");

        try

        {

            store.closeRecordStore();

            fail("recordStoreNotOpenException expected ");

        }

        catch (RecordStoreNotOpenException noe)

        {

            //test OK

        }

        catch (Exception e)

        {

            fail("Wrong exception " + e);

        }

        //8. deleteRecordStore(null)

        System.out.println("8. deleteRecordStore(null)");

        try

        {

            RecordStore.deleteRecordStore(null);

            fail("RecordStoreException expected");

        }

        catch (RecordStoreException rse) {}

    }

    public void testUsingSharedRecordStore()

    {

        System.out.println("RecordStoreTest.testUsingSharedRecordStore()");

        RecordStore store = null;

        // keep these in sync with CreateSharedStore

        String vendorName = CreateSharedStore.VENDORNAME;

        String suiteName  = CreateSharedStore.SUITENAME;

        try

        {

            // 1: Trying to open private store

            System.out.println("1: Trying to open private store");

            for (int i = 0; i<CreateSharedStore.PRIVATESTORES.length; i++)

            {

                try

                {

                    store = RecordStore.openRecordStore(CreateSharedStore.PRIVATESTORES[i], vendorName, suiteName);

                    store.closeRecordStore();

                    fail("SecurityException was not thrown");

                }

                catch (SecurityException re) {}

            }

            // 2: Trying to open non-existing store

            System.out.println("2: Trying to open non-existing store");

            try

            {

                store = RecordStore.openRecordStore("non-existing store", vendorName, suiteName);

                store.closeRecordStore();

                fail("RecordStoreNotFoundException was not thrown");

            }

            catch (RecordStoreNotFoundException re) {}

            // 3: Open shared store

            System.out.println("3: Open shared store");

            for (int i = 0; i<CreateSharedStore.SHAREDSTORES.length; i++)

            {

                try

                {

                    store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[i], vendorName, suiteName);

                    store.closeRecordStore();

                }

                catch (Exception re)

                {

                    fail("Exception not expected " + re);

                }

            }

            // 4: Using writable shared store

            System.out.println("4: Using writable shared store");

            store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[0], vendorName, suiteName);

            int recordId = store.addRecord(null, 0, 0);

            store.setRecord(recordId, new byte[1000], 0, 1000);

            store.deleteRecord(recordId);

            store.closeRecordStore();

            // 5: Using writable shared store - enumeration

            System.out.println("5: Using writable shared store - enumeration");

            store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[0], vendorName, suiteName);

            RecordEnumeration enumeration = store.enumerateRecords(null, null, true);

            assertEquals(enumeration.numRecords(), store.getNumRecords());

            try

            {

                while (true)

                {

                    int id  = enumeration.nextRecordId();

                    // go back to get the record

                    if (enumeration.hasPreviousElement())

                    {

                        enumeration.previousRecordId();

                    }

                    else

                    {

                        enumeration.reset();

                    }

                    byte[] orig = store.getRecord(id);

                    byte[] data = enumeration.nextRecord();

                    assertEquals(orig, data);

                }

            }

            catch (InvalidRecordIDException re) {}

            enumeration.destroy();

            store.closeRecordStore();

            // 6: Using non-writable shared store

            System.out.println("6: Using non-writable shared store");

            store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[1], vendorName, suiteName);

            try

            {

                store.addRecord(null, 0, 0);

                fail("SecurityException was not thrown (add)");

            }

            catch (SecurityException re) {}

            try

            {

                store.setRecord(1, new byte[1000], 0, 1000);

                fail("SecurityException was not thrown (set)");

            }

            catch (SecurityException re) {}

            try

            {

                store.deleteRecord(recordId);

                fail("SecurityException was not thrown (delete)");

            }

            catch (SecurityException re) {}

            store.closeRecordStore();

            // 7: Using non-writable shared store - enumeration

            System.out.println("7: Using non-writable shared store - enumeration");

            store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[1], vendorName, suiteName);

            enumeration = store.enumerateRecords(null, null, true);

            assertEquals(enumeration.numRecords(), store.getNumRecords());

            try

            {

                while (true)

                {

                    int id  = enumeration.nextRecordId();

                    // go back to get the record

                    if (enumeration.hasPreviousElement())

                    {

                        enumeration.previousRecordId();

                    }

                    else

                    {

                        enumeration.reset();

                    }

                    byte[] orig = store.getRecord(id);

                    byte[] data = enumeration.nextRecord();

                    assertEquals(orig, data);

                }

            }

            catch (InvalidRecordIDException re) {}

            enumeration.destroy();

            store.closeRecordStore();

            // 8: Writable shared store - setMode

            System.out.println("8: Writable shared store - setMode");

            store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[0], vendorName, suiteName);

            try

            {

                store.setMode(RecordStore.AUTHMODE_ANY, true);

                fail("SecurityException was not thrown");

            }

            catch (SecurityException re) {}

            store.closeRecordStore();

            // 9: Non-writable shared store - setMode

            System.out.println("9: Non-writable shared store - setMode");

            store = RecordStore.openRecordStore(CreateSharedStore.SHAREDSTORES[1], vendorName, suiteName);

            try

            {

                store.setMode(RecordStore.AUTHMODE_ANY, true);

                fail("SecurityException was not thrown");

            }

            catch (SecurityException re) {}

            store.closeRecordStore();

        }

        catch (Exception e)

        {

            e.printStackTrace();

            fail("Exception not expected " + e);

        }

    }

    public void testGetCommonProperties()

    {

        // test common record store properties (size, version, last modified)

        System.out.println("RecordStoreTest.testGetCommonProperties()");

        RecordStore store = null;

        String rec_store_name = "testGetCommonProperties";

        //1: getVersion / getLastModified check

        System.out.println("1: getVersion / getLastModified check");

        try

        {

            store = RecordStore.openRecordStore(rec_store_name, true);

            int ver1 = store.getVersion();

            long time1 = store.getLastModified();

            try

            {

                Thread.sleep(50);

            }

            catch (InterruptedException ie)

            {

            }

            byte data[] = {1, 2, 3};

            store.addRecord(data, 0, data.length);

            int ver2 = store.getVersion();