/*

* Copyright (c) 2009 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:

*

*/

import java.util.Enumeration;

import javax.microedition.location.*;

public class LandmarkStoreTest extends ViperUnitTest

{

    static final int MAX_NAME_LENGTH = 255;

    static final int MAX_CATEGORY_LENGTH = 124;

    static final int MAX_DESCRIPTION_LENGTH = 4095;

    static final int MAX_ADDRESSFIELD_LENGTH = 255;

    static final String extension = "23";

    static final String street = "11 Mount Avenue";

    static final String city = "London";

    static final String county = "Ealing";

    static final String postal_code = "W5 1QB";

    static final String state = "England";

    static final String district = "Middlesex";

    static final String country = "United Kingdom";

    static final String country_code = "GB";

    static final String building_name = "The Castle";

    static final String building_floor = "3";

    static final String building_room = "Front Room";

    static final String building_zone = "Upstairs";

    static final String crossing1 = "Mount Avenue";

    static final String crossing2 = "Eaton Rise";

    static final String url = "http://www.upmystreet.co.uk";

    static final String phone_number = "+358401234567";

    static final String searchCategory0 = "category0";

    static final String searchCategory1 = "category1";

    static final String searchCategory2 = "category2";

    static final String searchName0 = "name0"; // Will not be added

    static final String searchName1 = "name1"; // Will be added once

    static final String searchName2 = "name2"; // Will be added twice

    static final String searchName3 = "name3"; // Will be added three times

    private LandmarkStore ls;

    private String iCategory;

    public LandmarkStoreTest()

    {

        super("LandmarkStoreTest");

    }

    // These tests assume the default Landmark store is empty to begin with

    protected void runTest() throws java.lang.Throwable

    {

        testGetInstance();

        testDeleteLandmarkBadArguments();

        testGetLandmarksEmptyStore();

        // ---------------------------------------------------

        // Test addLandmark(Landmark, String category = null),

        // deleteLandmark(Landmark), updateLandmark(Landmark)

        // and getLandmarks()

        // ---------------------------------------------------

        iCategory = null;

        testAddGetDeleteAndUpdateLandmarks();

        // ---------------------------------------------------

        // Test addCategory(String), deleteCategory(String)

        // and getCategories()

        // ---------------------------------------------------

        testAddCategoryBadArguments();

        testDeleteCategoryBadArguments();

        testAddDeleteCategory();

        testAddDeleteManyCategories();

        testAddCategoryTruncate();

        testAddLandmarkToCategory1();

        testAddLandmarkToCategory2();

        testAddLandmarkToCategory3();

        testAddLandmarkToCategoryDeleteCategory();

        testAddLandmarkSameNameDifferentCategory();

        // Test addLandmark(Landmark, String category = "Work")

        iCategory = "Work";

        testAddGetDeleteAndUpdateLandmarks();

        testRemoveLandmarkFromCategoryBadArguments();

        testRemoveLandmarkFromCategory();

        testRemoveLandmarkFromCategory2();

        testGetLandmarksByNameBadArguments();

        testGetLandmarksByName();

        testGetLandmarksByNameUncategorized();

        testGetLandmarksByNameWildcards();

        testGetLandmarksByCategoryBadArguments();

        testGetLandmarksByCategory();

        testGetLandmarksByNameAndCategory();

        testGetLandmarksByAreaBadArguments();

        testGetLandmarksByArea();

        testGetLandmarksByArea2();

        testGetLandmarksByAreaAndCategory();

        testEnumerationDeleteLandmark1();

        testEnumerationDeleteLandmark2();

        // Make sure the tests cleaned the store

        assertEmptyLandmarkStore();

    }

    void testAddGetDeleteAndUpdateLandmarks() throws Exception

    {

        if (iCategory != null)

        {

            ls = getDefaultLandmarkStore();

            ls.addCategory(iCategory);

        }

        testAddLandmarkBadArguments();

        testAddDeleteLandmark1();

        testAddDeleteLandmark2();

        testAddDeleteLandmark3();

        testAddDeleteLandmark4();

        testAddLandmarkTwice();

        testAddLandmarkNoUpdate();

        testAddLandmarkSameName();

        testAddDeleteAddLandmark();

        testAddLandmarkTruncate();

        testAddLandmarkEmptyStrings();

        testUpdateLandmarkBadArguments();

        testUpdateLandmark1();

        testUpdateLandmark2();

        testUpdateLandmarkTruncate();

        testAddDeleteUpdateLandmark();

        testGetAllLandmarks();

        if (iCategory != null)

        {

            ls = getDefaultLandmarkStore();

            ls.deleteCategory(iCategory);

        }

    }

    void testGetInstance()

    {

        setCurrentTest("testGetInstance()");

        // Get default store

        ls = LandmarkStore.getInstance(null);

        assertTrue(ls != null, "Instance was null for default store");

    }

    void testAddLandmarkBadArguments() throws Exception

    {

        setCurrentTest("testAddLandmarkBadArguments()");

        ls = getDefaultLandmarkStore();

        try

        {

            // Add with null Landmark parameter

            ls.addLandmark(null, iCategory);

            assertTrue(false, "NullPointerException not thrown");

        }

        catch (NullPointerException npe)

        {

            // Exception was thrown correctly

            assertNoMessage(npe);

        }

        Landmark lm = new Landmark("test", null, null, null);

        try

        {

            String badCategory = "This category does not exist";

            ls.addLandmark(lm, badCategory); // Add with nonexisting category

            assertTrue(false, "IllegalArgumentException not thrown 1");

        }

        catch (IllegalArgumentException iae)

        {

            // Exception was thrown correctly

            assertNoMessage(iae);

        }

        try

        {

            lm.setName(new String(new char[MAX_NAME_LENGTH + 1]));

            ls.addLandmark(lm, iCategory); // Add Landmark with too long name

            assertTrue(false, "IllegalArgumentException not thrown 2");

        }

        catch (IllegalArgumentException iae)

        {

            // Exception was thrown correctly

            assertNoMessage(iae);

        }

    }

    void testDeleteLandmarkBadArguments() throws Exception

    {

        setCurrentTest("testDeleteLandmarkBadArguments");

        ls = getDefaultLandmarkStore();

        try

        {

            ls.deleteLandmark(null); // Delete with null Landmark parameter

            assertTrue(false, "NullPointerException not thrown");

        }

        catch (NullPointerException npe)

        {

            // Exception was thrown correctly

            assertNoMessage(npe);

        }

        try

        {

            Landmark lm = new Landmark("test", null, null, null);

            ls.deleteLandmark(lm); // Try to delete a Landmark that was never

            // added

            assertTrue(false, "LandmarkException not thrown");

        }

        catch (LandmarkException le)

        {

            // Exception was thrown correctly

            assertNoMessage(le);

        }

    }

    void testGetLandmarksEmptyStore() throws Exception

    {

        setCurrentTest("testGetLandmarksEmptyStore()");

        ls = getDefaultLandmarkStore();

        Enumeration e = ls.getLandmarks();

        assertTrue(e == null, "Expected getLandmarks to return null");

    }

    // Create a Landmark object, store it in the LandmarkStore, check

    // that it can be found again and then delete it

    void testAddDeleteLandmark1() throws Exception

    {

        setCurrentTest("testAddDeleteLandmark1()");

        String name = "Nowhere";

        // Create a new Landmark object with only name set

        Landmark lm = new Landmark(name, null, null, null);

        saveRetrieveDelete(lm);

    }

    void testAddDeleteLandmark2() throws Exception

    {

        setCurrentTest("testAddDeleteLandmark2()");

        String name = "Somewhere";

        String desc = "It's somewhere but noone knows where it really is";

        // Create a new Landmark object with only name set

        Landmark lm = new Landmark(name, desc, null, null);

        saveRetrieveDelete(lm);

    }

    void testAddDeleteLandmark3() throws Exception

    {

        setCurrentTest("testAddDeleteLandmark3()");

        String name = "North pole";

        String desc = "Santas workshop, whats that address again?";

        QualifiedCoordinates coords = new QualifiedCoordinates(90.0f, 0.0f,

                0.0f, 10.0f, 10.0f);

        // Create a new Landmark object with only name set

        Landmark lm = new Landmark(name, desc, coords, null);

        saveRetrieveDelete(lm);

    }

    void testAddDeleteLandmark4() throws Exception

    {

        setCurrentTest("testAddDeleteLandmark4()");

        String name = "Office";

        String desc = "Where you work";

        QualifiedCoordinates coords = new QualifiedCoordinates(57.0f, 17.0f,

                34.0f, 50.0f, 80.0f);

        AddressInfo address = new AddressInfo();

        address.setField(AddressInfo.EXTENSION, extension);

        address.setField(AddressInfo.STREET, street);

        address.setField(AddressInfo.POSTAL_CODE, postal_code);

        address.setField(AddressInfo.CITY, city);

        address.setField(AddressInfo.COUNTY, county);

        address.setField(AddressInfo.DISTRICT, district);

        address.setField(AddressInfo.STATE, state);

        address.setField(AddressInfo.COUNTRY, country);

        address.setField(AddressInfo.COUNTRY_CODE, country_code);

        address.setField(AddressInfo.BUILDING_NAME, building_name);

        address.setField(AddressInfo.BUILDING_FLOOR, building_floor);

        address.setField(AddressInfo.BUILDING_ROOM, building_room);

        address.setField(AddressInfo.BUILDING_ZONE, building_zone);

        address.setField(AddressInfo.CROSSING1, crossing1);

        address.setField(AddressInfo.CROSSING2, crossing2);

        address.setField(AddressInfo.URL, url);

        address.setField(AddressInfo.PHONE_NUMBER, phone_number);

        // Create a new Landmark object

        Landmark lm = new Landmark(name, desc, coords, address);

        saveRetrieveDelete(lm);

    }

    // Tests that a Landmark can be added twice.

    void testAddLandmarkTwice() throws Exception

    {

        setCurrentTest("testAddLandmarkTwice()");

        String name = "Add this landmark twice";

        Landmark lm = new Landmark(name, null, null, null);

        ls = getDefaultLandmarkStore();

        ls.addLandmark(lm, iCategory);

        ls.addLandmark(lm, iCategory);

        Enumeration e = ls.getLandmarks();

        int count = findLandmarks(e, new String[] { name });

        assertTrue(count == 1, "Wrong number of landmarks found");

        ls.deleteLandmark(lm);

    }

    // Tests that addLandmark can not be used as updateLandmark.

    void testAddLandmarkNoUpdate() throws Exception

    {

        setCurrentTest("testAddLandmarkNoUpdate()");

        String name = "Add this landmark twice";

        Landmark lm = new Landmark(name, null, null, null);

        ls = getDefaultLandmarkStore();

        ls.addLandmark(lm, iCategory);

        // Check that addLandmark is not doing what updateLandmark should do

        lm.setDescription("Whatever");

        lm.setQualifiedCoordinates(new QualifiedCoordinates(0, 0, 0, 0, 0));

        lm.setAddressInfo(new AddressInfo());

        ls.addLandmark(lm, iCategory);

        Enumeration e = ls.getLandmarks();

        Landmark fetchedLm = findLandmark(e, name);

        checkLandmark(fetchedLm, name, null, null, null);

        ls.deleteLandmark(lm);

    }

    // Tests that Landmarks with the same name can be added.

    void testAddLandmarkSameName() throws Exception

    {

        setCurrentTest("testAddLandmarkSameName()");

        String name = "Glenn";

        Landmark lm1 = new Landmark(name, null, null, null);

        String desc = "Another landmark with name=Glenn";

        Landmark lm2 = new Landmark(name, desc, null, null);

        ls = getDefaultLandmarkStore();

        ls.addLandmark(lm1, iCategory);

        ls.addLandmark(lm2, iCategory);

        Enumeration e = ls.getLandmarks();

        int count = findLandmarks(e, new String[] { name, name });

        assertTrue(count == 2, "Wrong number of landmarks found");

        ls.deleteLandmark(lm1);

        ls.deleteLandmark(lm2);

    }

    // Tests that a Landmark can be added, then deleted and added again.

    void testAddDeleteAddLandmark() throws Exception

    {

        setCurrentTest("testAddDeleteAddLandmark()");

        ls = getDefaultLandmarkStore();

        String name = "LandmarkToBeAddedDeletedAndAddedAgain";

        Landmark lm = new Landmark(name, null, null, null);

        Enumeration e;

        ls.addLandmark(lm, iCategory);

        e = ls.getLandmarks();

        Landmark fetchedLm = findLandmark(e, name);

        ls.deleteLandmark(fetchedLm);

        ls.addLandmark(lm, iCategory);

        e = ls.getLandmarks();

        int count = findLandmarks(e, new String[] { name });

        assertTrue(count == 1, "Wrong number of landmarks found");

        ls.deleteLandmark(lm);

    }

    // Tests that description and address are truncated if they are too long

    void testAddLandmarkTruncate() throws Exception

    {

        setCurrentTest("testAddLandmarkTruncate()");

        ls = getDefaultLandmarkStore();

        String name = "Longest address in the world :)";

        String maxDescription = new String(new char[MAX_DESCRIPTION_LENGTH]);

        String tooLongDescription = maxDescription + "could be a lot more";

        String maxAddrField = new String(new char[MAX_ADDRESSFIELD_LENGTH]);

        String tooLongAddrField = maxAddrField + "some more";

        AddressInfo tooLongAddr = new AddressInfo();

        for (int i = 0; i < 17; ++i)

        {

            tooLongAddr.setField(i + 1, tooLongAddrField);

        }

        // Add the landmark that has info with too long length

        Landmark lm = new Landmark(name, tooLongDescription, null, tooLongAddr);

        ls.addLandmark(lm, iCategory);

        // All fields should be truncated to max length

        AddressInfo expectedAddr = new AddressInfo();

        for (int i = 0; i < 17; ++i)

        {

            expectedAddr.setField(i + 1, maxAddrField);

        }

        Enumeration e = ls.getLandmarks();

        Landmark fetchedLm = findLandmark(e, name);

        checkLandmark(fetchedLm, name, maxDescription, null, expectedAddr);

        ls.deleteLandmark(lm);

    }

    void testUpdateLandmarkBadArguments() throws Exception

    {

        setCurrentTest("testUpdateLandmarkBadArguments");

        ls = getDefaultLandmarkStore();

        try

        {

            ls.updateLandmark(null); // Update with null Landmark parameter

            assertTrue(false, "NullPointerException not thrown");

        }

        catch (NullPointerException npe)

        {

            // Exception was thrown correctly

        }

        Landmark lm = new Landmark("test", null, null, null);

        try

        {

            ls.updateLandmark(lm); // Update without adding first

            assertTrue(false, "LandmarkException not thrown 1");

        }

        catch (LandmarkException iae)

        {

            // Exception was thrown correctly

        }

        try

        {

            ls.addLandmark(lm, iCategory);

            ls.deleteLandmark(lm);

            ls.updateLandmark(lm); // Landmark no longer belongs to store

            assertTrue(false, "LandmarkException not thrown 2");

        }

        catch (LandmarkException iae)

        {

            // Exception was thrown correctly

        }

        try

        {

            ls.addLandmark(lm, iCategory);

            lm.setName(new String(new char[MAX_NAME_LENGTH + 1]));

            ls.updateLandmark(lm); // Update Landmark with too long name

            assertTrue(false, "IllegalArgumentException not thrown 3");

        }

        catch (IllegalArgumentException iae)