/*

* 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.*;

/* Test cases for verifying that functionality is according to MIDP2.1 spec.

 * These tests will verify that argument validation is done correctly,

 * correct exceptions are thrown and behavior follows the spec

 */

public class TestRecordEnumeration extends TestCase

{

    public TestRecordEnumeration() {}

    public TestRecordEnumeration(String sTestName, TestMethod rTestMethod)

    {

        super(sTestName, rTestMethod);

    }

    public Test suite()

    {

        TestSuite aSuite = new TestSuite();

        aSuite.addTest(new TestRecordEnumeration("testDestroy", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testDestroy();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testHasNextElement", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testHasNextElement();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testHasPreviousElement", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testHasPreviousElement();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testIsKeptUpdated", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testIsKeptUpdated();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testKeepUpdated", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testKeepUpdated();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testNextRecord", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testNextRecord();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testNextRecordId", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testNextRecordId();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testNumRecords", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testNumRecords();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testPreviousRecord", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testPreviousRecord();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testPreviousRecordId", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testPreviousRecordId();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testRebuild", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testRebuild();

            }

        }));

        aSuite.addTest(new TestRecordEnumeration("testReset", new TestMethod()

        {

            public void run(TestCase tc)

            {

                ((TestRecordEnumeration) tc).testReset();

            }

        }));

        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]);

        }

    }

    String[] iData = { "Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf",

                       "Hotel", "India", "Juliet", "Kilo", "Lima", "Mike", "November",

                       "Oscar", "Papa", "Quebec", "Romeo", "Sierra", "Tango", "Uniform",

                       "Victor", "Whiskey", "Xray", "Yankee", "Zulu"

                     };

    private void populateRecordStore(RecordStore aStore) throws RecordStoreException

    {

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

        {

            aStore.addRecord(iData[i].getBytes(), 0, iData[i].getBytes().length);

        }

    }

    class DefaultFilter implements RecordFilter

    {

        public boolean matches(byte[] candidate)

        {

            if (candidate[0] > 25)

                return true;

            else

                return false;

        }

    }

    class DefaultComparator implements RecordComparator

    {

        public int compare(byte[] rec1, byte[] rec2)

        {

            if (rec1[0] < rec2[0])

                return RecordComparator.PRECEDES;

            else if (rec1[0] > rec2[0])

                return RecordComparator.FOLLOWS;

            else

                return RecordComparator.EQUIVALENT;

        }

    }

    public void testDestroy()

    {

        System.out.println("TestRecordEnumeration.testDestroy()");

        RecordStore store = null;

        String rec_store_name = "destroy";

        try

        {

            // 0: Init

            System.out.println("0: Init");

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

            store = RecordStore.openRecordStore(rec_store_name, true);

            populateRecordStore(store);

            // 1: destroy

            System.out.println("1: destroy");

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

            enumeration.destroy();

            // 2: calling methods after destroy

            System.out.println("2: calling methods after destroy");

            try

            {

                enumeration.destroy();

                fail("IllegalStateException not thrown - destroy");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.hasNextElement();

                fail("IllegalStateException not thrown - hasNextElement");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.hasPreviousElement();

                fail("IllegalStateException not thrown - hasPreviousElement");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.isKeptUpdated();

                fail("IllegalStateException not thrown - isKeptUpdated");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.keepUpdated(true);

                fail("IllegalStateException not thrown - keepUpdated");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.nextRecord();

                fail("IllegalStateException not thrown - nextRecord");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.nextRecordId();

                fail("IllegalStateException not thrown - nextRecordId");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.numRecords();

                fail("IllegalStateException not thrown - numRecords");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.previousRecord();

                fail("IllegalStateException not thrown - previousRecord");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.rebuild();

                fail("IllegalStateException not thrown - rebuild");

            }

            catch (IllegalStateException re) {}

            try

            {

                enumeration.reset();

                fail("IllegalStateException not thrown - reset");

            }

            catch (IllegalStateException re) {}

        }

        catch (Exception e)

        {

            e.printStackTrace();

            fail("Unexpected exception " + e);

        }

        finally

        {

            try

            {

                store.closeRecordStore();

            }

            catch (Exception e) {}

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

        }

    }

    public void testHasNextElement()

    {

        System.out.println("TestRecordEnumeration.testHasNextElement()");

        RecordStore store = null;

        String rec_store_name = "hasNextElement";

        try

        {

            // 0: Init

            System.out.println("0: Init");

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

            store = RecordStore.openRecordStore(rec_store_name, true);

            // 1: empty store

            System.out.println("1: empty store");

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

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

            assertTrue(enumeration.hasNextElement() == false);

            enumeration.destroy();

            // 2: traverse all records in the record store

            System.out.println("2: traverse all records in the record store");

            populateRecordStore(store);

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

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

            int count = 0;

            while (enumeration.hasNextElement())

            {

                enumeration.nextRecordId();

                count++;

            }

            assertEquals(enumeration.numRecords(), count);

            enumeration.destroy();

        }

        catch (Exception e)

        {

            e.printStackTrace();

            fail("Unexpected exception " + e);

        }

        finally

        {

            try

            {

                store.closeRecordStore();

            }

            catch (Exception e) {}

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

        }

    }

    public void testHasPreviousElement()

    {

        System.out.println("TestRecordEnumeration.testHasPreviousElement()");

        RecordStore store = null;

        String rec_store_name = "hasPreviousElement";

        try

        {

            // 0: Init

            System.out.println("0: Init");

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

            store = RecordStore.openRecordStore(rec_store_name, true);

            // 1: empty store

            System.out.println("1: empty store");

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

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

            assertTrue(enumeration.hasPreviousElement() == false);

            enumeration.destroy();

            // 2: traverse all records in the record store

            System.out.println("2: traverse all records in the record store");

            populateRecordStore(store);

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

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

            try

            {

                while (true)

                {

                    enumeration.nextRecordId();

                }

            }

            catch (InvalidRecordIDException e) {}

            int count = 0;

            while (enumeration.hasPreviousElement())

            {

                enumeration.previousRecordId();

                count++;

            }

            assertEquals(enumeration.numRecords(), count);

            enumeration.destroy();

        }

        catch (Exception e)

        {

            e.printStackTrace();

            fail("Unexpected exception " + e);

        }

        finally

        {

            try

            {

                store.closeRecordStore();

            }

            catch (Exception e) {}

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

        }

    }

    public void testIsKeptUpdated()

    {

        System.out.println("TestRecordEnumeration.testIsKeptUpdated()");

        RecordStore store = null;

        String rec_store_name = "isKeptUpdated";

        try

        {

            // 0: Init

            System.out.println("0: Init");

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

            store = RecordStore.openRecordStore(rec_store_name, true);

            populateRecordStore(store);

            // 1: isKeptUpdated after open

            System.out.println("1: isKeptUpdated after open");

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

            assertTrue(enumeration.isKeptUpdated() == true);

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

            assertTrue(enumeration.isKeptUpdated() == false);

            enumeration.destroy();

            // 2: isKeptUpdated after keepUpdated

            System.out.println("2: isKeptUpdated after keepUpdated");

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

            enumeration.keepUpdated(true);

            assertTrue(enumeration.isKeptUpdated() == true);

            enumeration.keepUpdated(false);

            assertTrue(enumeration.isKeptUpdated() == false);

            enumeration.destroy();

        }

        catch (Exception e)

        {

            e.printStackTrace();

            fail("Unexpected exception " + e);

        }

        finally

        {

            try

            {

                store.closeRecordStore();

            }

            catch (Exception e) {}

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

        }

    }

    public void testKeepUpdated()

    {

        System.out.println("TestRecordEnumeration.testKeepUpdated()");

        RecordStore store = null;

        String rec_store_name = "keepUpdated";

        try

        {

            // 0: Init

            System.out.println("0: Init");

            try

            {

                RecordStore.deleteRecordStore(rec_store_name);

            }

            catch (Exception e) {}

            store = RecordStore.openRecordStore(rec_store_name, true);

            populateRecordStore(store);

            // 1: keepUpdated false (open true)

            System.out.println("1: keepUpdated false  (open true)");

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

            assertTrue(enumeration.isKeptUpdated() == true);

            store.addRecord(null, 0, 0);

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

            enumeration.keepUpdated(false);

            store.addRecord(null, 0, 0);

            assertTrue(enumeration.isKeptUpdated() == false);

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

            enumeration.destroy();

            // 2: keepUpdated false (open false)