diff -r f5050f1da672 -r 04becd199f91 javaextensions/location/tsrc/vipertest/src/LandmarkStoreTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaextensions/location/tsrc/vipertest/src/LandmarkStoreTest.java Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,2055 @@ +/* +* 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) + { + // Exception was thrown correctly + } + + ls.deleteLandmark(lm); + } + + // Add a landmark to the LandmarkStore and update with more and more + // information. + void testUpdateLandmark1() throws Exception + { + setCurrentTest("testUpdateLandmark1()"); + + // Create a new Landmark object + String name = "Home"; + Landmark lm = new Landmark(name, null, null, null); + + ls = getDefaultLandmarkStore(); + + // Save the landmark + ls.addLandmark(lm, iCategory); + + Landmark fetchedLm = null; + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, null, null, null); + + // Update the landmark with a decription + String description = "There is no place like it"; + lm.setDescription(description); + ls.updateLandmark(lm); + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, description, null, null); + + // Update the landmark with QualifiedCoordinates and change the name + QualifiedCoordinates coords = new QualifiedCoordinates(-10.2f, -107.8f, + -4.5f, 11.9f, 5.1f); + + lm.setQualifiedCoordinates(coords); + name = "My place"; + lm.setName(name); + + ls.updateLandmark(lm); + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, description, coords, null); + + // Update the landmark with AddressInfo + 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); + + lm.setAddressInfo(address); + ls.updateLandmark(lm); + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, description, coords, address); + + // Finally, remove the landmark + ls.deleteLandmark(lm); + } + + // Add a landmark to the LandmarkStore with all the information set and + // update by removing information. + void testUpdateLandmark2() throws Exception + { + setCurrentTest("testUpdateLandmark2()"); + + // Create a new Landmark object + String name = "Home"; + String desc = "There is no place like it"; + QualifiedCoordinates coords = new QualifiedCoordinates(-10.2f, -107.8f, + -4.5f, 11.9f, 5.1f); + 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); + Landmark lm = new Landmark(name, desc, coords, address); + + ls = getDefaultLandmarkStore(); + + // Save the landmark + ls.addLandmark(lm, iCategory); + + Landmark fetchedLm = null; + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, desc, coords, address); + + // Remove decription + lm.setDescription(null); + ls.updateLandmark(lm); + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, null, coords, address); + + // Remove QualifiedCoordinates + lm.setQualifiedCoordinates(null); + ls.updateLandmark(lm); + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, null, null, address); + + // Remove AddressInfo + lm.setAddressInfo(null); + ls.updateLandmark(lm); + + fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, null, null, null); + + // Finally, remove the landmark + ls.deleteLandmark(lm); + } + + void testUpdateLandmarkTruncate() throws Exception + { + setCurrentTest("testUpdateLandmarkTruncate()"); + + ls = getDefaultLandmarkStore(); + + String name = "Update with lots of info later"; + Landmark lm = new Landmark(name, null, null, null); + ls.addLandmark(lm, iCategory); + + 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); + } + + // Update the landmark with info that has length longer than max + lm.setDescription(tooLongDescription); + lm.setAddressInfo(tooLongAddr); + ls.updateLandmark(lm); + + // 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 testAddDeleteUpdateLandmark() throws Exception + { + setCurrentTest("testAddDeleteUpdateLandmark()"); + + ls = getDefaultLandmarkStore(); + + String name = "AddDeleteUpdateLandmark"; + Landmark lm = new Landmark(name, null, null, null); + + // Add, get and delete the landmark + ls.addLandmark(lm, iCategory); + Enumeration e = ls.getLandmarks(); + Landmark fetchedLm = findLandmark(e, name); + ls.deleteLandmark(lm); + + // Try to update the landmark we just deleted + try + { + fetchedLm.setDescription("Description"); + ls.updateLandmark(fetchedLm); + assertTrue(false, "LandmarkException not thrown"); + } + catch (LandmarkException le) + { + // Exception was thrown correctly + assertNoMessage(le); + } + } + + // List all landmarks. + void testGetAllLandmarks() throws Exception + { + setCurrentTest("testGetAllLandmarks()"); + + final String BASE_NAME = "GetLandmarksTest"; + final int NUM_LANDMARKS = 10; + String[] names = new String[NUM_LANDMARKS]; + + ls = getDefaultLandmarkStore(); + + for (int i = 0; i < NUM_LANDMARKS; ++i) + { + names[i] = BASE_NAME + i; + Landmark lm = new Landmark(names[i], null, null, null); + ls.addLandmark(lm, iCategory); + } + + // Retrieve the enumeration of landmarks + Enumeration e = ls.getLandmarks(); + + int count = findLandmarks(e, names); + assertTrue(count == NUM_LANDMARKS, "Wrong number of Landmarks found"); + + // Delete all the added landmarks + e = ls.getLandmarks(); + while (e.hasMoreElements()) + { + ls.deleteLandmark((Landmark) e.nextElement()); + } + } + + void testAddCategoryBadArguments() throws Exception + { + setCurrentTest("testAddCategoryBadArguments()"); + + ls = getDefaultLandmarkStore(); + + try + { + ls.addCategory(null); // Add category with null parameter + assertTrue(false, "NullPointerException not thrown"); + } + catch (NullPointerException npe) + { + // Exception was thrown correctly + } + + try + { + ls.addCategory(""); // Add category with empty string parameter + assertTrue(false, "IllegalArgumentException not thrown"); + } + catch (IllegalArgumentException iae) + { + // Exception was thrown correctly + } + + String category = "Try to add this category twice"; + ls.addCategory(category); + + try + { + ls.addCategory(category); // Category already exists + assertTrue(false, "IllegalArgumentException not thrown"); + } + catch (IllegalArgumentException iae) + { + // Exception was thrown correctly + } + + ls.deleteCategory(category); + } + + void testDeleteCategoryBadArguments() throws Exception + { + setCurrentTest("testDeleteCategoryBadArguments()"); + + ls = getDefaultLandmarkStore(); + + try + { + ls.deleteCategory(null); // Delete category with null parameter + assertTrue(false, "NullPointerException not thrown"); + } + catch (NullPointerException npe) + { + // Exception was thrown correctly + } + + String category = "Nonexisting category"; + ls.deleteCategory(category); // This should be a silent failure + ls.deleteCategory(category); // Try again just to make sure :) + + ls.deleteCategory(""); // Empty string should fail silently + + // Silent failure if category name is too long + ls.deleteCategory(new String(new char[MAX_CATEGORY_LENGTH + 1])); + } + + // Tests that new categories can be added and deleted. + void testAddDeleteCategory() throws Exception + { + setCurrentTest("testAddDeleteCategory()"); + + String category = "AddCategoryTest Category"; + + ls = getDefaultLandmarkStore(); + + // Add category + ls.addCategory(category); + + // Check that the category was added + Enumeration e = ls.getCategories(); + findCategory(e, category); + + // Delete the category + ls.deleteCategory(category); + + // Check that category has been removed + e = ls.getCategories(); + while (e.hasMoreElements()) + { + String s = (String) e.nextElement(); + assertTrue(!s.equals(category), "Category was not removed"); + } + } + + void testAddDeleteManyCategories() throws Exception + { + setCurrentTest("testAddDeleteManyCategories()"); + + // A variety of valid category names + String[] categories = new String[] { "q", "Dots ...", "Exclamation!", + "(parentesis)", "percentage%", "hashmark#", "at@", "et&", + "commas,,," + }; + + ls = getDefaultLandmarkStore(); + + // Quick Add and Delete of categories + for (int i = 0; i < categories.length; ++i) + { + ls.addCategory(categories[i]); + ls.deleteCategory(categories[i]); + } + + // Add many categories + String category = "Test_Category_"; + + // Add categories + for (int i = 0; i < 100; ++i) + { + ls.addCategory(category + i); + } + + // Delete categories + for (int i = 0; i < 100; ++i) + { + ls.deleteCategory(category + i); + } + } + + void testAddCategoryTruncate() throws Exception + { + setCurrentTest("testAddCategoryTruncate()"); + + ls = getDefaultLandmarkStore(); + + String maxCategoryName = new String(new char[MAX_CATEGORY_LENGTH]); + + // Add category with too long name + String tooLongCategoryName = maxCategoryName + "extra"; + ls.addCategory(tooLongCategoryName); + + // Check that the category was added + Enumeration e = ls.getCategories(); + // Category name should be truncated to max length + findCategory(e, maxCategoryName); + + // Try to delete with the too long category name + ls.deleteCategory(tooLongCategoryName); + // Make sure the category is still there + e = ls.getCategories(); + findCategory(e, maxCategoryName); + + // Delete the category + ls.deleteCategory(maxCategoryName); + + // Check that category has been removed + e = ls.getCategories(); + while (e.hasMoreElements()) + { + String s = (String) e.nextElement(); + assertTrue(!maxCategoryName.equals(s), "Category was not removed"); + } + } + + void testAddLandmarkToCategory1() throws Exception + { + setCurrentTest("testAddLandmarkToCategory1()"); + + ls = getDefaultLandmarkStore(); + + // Create a category + String category = "ViperTest Sightseeing"; + ls.addCategory(category); + + // Create a new Landmark in the category + String name = "Eiffel Tower"; + Landmark lm = new Landmark(name, null, null, null); + ls.addLandmark(lm, category); + + // Get Landmarks by category + Enumeration e = ls.getLandmarks(category, null); + int count = findLandmarks(e, new String[] { name }); + assertTrue(count == 1, "Wrong number of Landmarks found"); + + ls.deleteLandmark(lm); + ls.deleteCategory(category); + } + + void testAddLandmarkToCategory2() throws Exception + { + setCurrentTest("testAddLandmarkToCategory2()"); + + ls = getDefaultLandmarkStore(); + + // Add a new Landmark to default category + String name = "Liseberg"; + Landmark lm = new Landmark(name, null, null, null); + ls.addLandmark(lm, null); + + // Create a category + String category = "Amuzement Parks"; + ls.addCategory(category); + + // Get Landmarks by category + Enumeration e = ls.getLandmarks(category, null); + assertTrue(e == null, "Category should have been empty"); + + // Add the Landmark to the category + ls.addLandmark(lm, category); + + // Get Landmarks by category + Enumeration e2 = ls.getLandmarks(category, null); + int count = findLandmarks(e2, new String[] { name }); + assertTrue(count == 1, "Wrong number of Landmarks found"); + + ls.deleteLandmark(lm); + ls.deleteCategory(category); + } + + void testAddLandmarkToCategory3() throws Exception + { + setCurrentTest("testAddLandmarkToCategory3()"); + + ls = getDefaultLandmarkStore(); + + // Add category1 + String category1 = "Food"; + ls.addCategory(category1); + findCategory(ls.getCategories(), category1); + + // Add category2 + String category2 = "Restuarants"; + ls.addCategory(category2); + findCategory(ls.getCategories(), category2); + + // Create a new Landmark in category1 + String name = "Da Pizza place"; + Landmark lm = new Landmark(name, null, null, null); + ls.addLandmark(lm, category1); + + // Add the Landmark to category2 + ls.addLandmark(lm, category2); + + // Get Landmarks by category1 + Enumeration e1 = ls.getLandmarks(category1, null); + int count1 = findLandmarks(e1, new String[] { name }); + assertTrue(count1 == 1, "Wrong number of Landmarks found"); + + // Get Landmarks by category2 + Enumeration e2 = ls.getLandmarks(category2, null); + int count2 = findLandmarks(e2, new String[] { name }); + assertTrue(count2 == 1, "Wrong number of Landmarks found"); + + ls.deleteLandmark(lm); + ls.deleteCategory(category1); + ls.deleteCategory(category2); + } + + void testAddLandmarkEmptyStrings() throws Exception + { + setCurrentTest("testAddLandmarkEmptyStrings()"); + + ls = getDefaultLandmarkStore(); + + try + { + Landmark lm = new Landmark("name", null, null, null); + ls.addLandmark(lm, ""); // Try to use empty string for category + assertTrue(false, "IllegalArgumentException not thrown"); + } + catch (IllegalArgumentException iae) + { + // Exception thrown correctly + } + + // Create AddressInfo with all fields set to empty strings + AddressInfo addr = new AddressInfo(); + for (int i = 0; i < 17; ++i) + { + addr.setField(i + 1, ""); + } + + String name = ""; + String description = " "; + Landmark lm = new Landmark(name, description, null, addr); + ls.addLandmark(lm, iCategory); // Should be ok + + // Get Landmarks + Enumeration e = ls.getLandmarks(); + Landmark fetchedLm = findLandmark(e, name); + checkLandmark(fetchedLm, name, description, null, addr); + + ls.deleteLandmark(lm); + } + + void testAddLandmarkToCategoryDeleteCategory() throws Exception + { + setCurrentTest("testAddLandmarkToCategoryDeleteCategory()"); + + ls = getDefaultLandmarkStore(); + + // Create a category + String category = "Museums"; + ls.addCategory(category); + + // Create a new Landmark in the category + String name = "Guggenheim"; + Landmark lm = new Landmark(name, null, null, null); + ls.addLandmark(lm, category); + + // Delete the category + ls.deleteCategory(category); + + // Get Landmarks by category + Enumeration e = ls.getLandmarks(null, category); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Make sure Landmark still exists + Landmark fetchedLm = findLandmark(ls.getLandmarks(), name); + checkLandmark(fetchedLm, name, null, null, null); + + ls.deleteLandmark(lm); + } + + void testAddLandmarkSameNameDifferentCategory() throws Exception + { + setCurrentTest("testAddLandmarkSameNameDifferentCategory()"); + + ls = getDefaultLandmarkStore(); + + // Create categories + String category1 = "category1"; + String category2 = "category2"; + ls.addCategory(category1); + ls.addCategory(category2); + + String name = "Same name"; + + // Create a new Landmark in category1 + String desc1 = "This landmark has a description"; + Landmark lm1 = new Landmark(name, desc1, null, null); + ls.addLandmark(lm1, category1); + + // Create a new Landmark in category2 + Landmark lm2 = new Landmark(name, null, null, null); + ls.addLandmark(lm2, category2); + + // Get Landmarks by category1 + Enumeration e = ls.getLandmarks(category1, null); + Landmark fetchedLm = findLandmark(e, name); + checkLandmark(fetchedLm, name, desc1, null, null); + + // Get Landmarks by category2 + e = ls.getLandmarks(category2, null); + fetchedLm = findLandmark(e, name); + checkLandmark(fetchedLm, name, null, null, null); + + // Get Landmarks by name + e = ls.getLandmarks(null, name); + int count = findLandmarks(e, new String[] { name, name }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + ls.deleteLandmark(lm1); + ls.deleteLandmark(lm2); + ls.deleteCategory(category1); + ls.deleteCategory(category2); + } + + void testRemoveLandmarkFromCategoryBadArguments() throws Exception + { + setCurrentTest("testRemoveLandmarkFromCategoryBadArguments"); + + ls = getDefaultLandmarkStore(); + + String category1 = "Cat1"; + String category2 = "Cat2"; + ls.addCategory(category1); + ls.addCategory(category2); + + // Add a landmark to category1 + Landmark lm = new Landmark("name", null, null, null); + ls.addLandmark(lm, category1); + + try + { + // Remove landmark from category with null Landmark parameter + ls.removeLandmarkFromCategory(null, category1); + assertTrue(false, "NullPointerException not thrown"); + } + catch (NullPointerException npe) + { + // Exception was thrown correctly + } + + try + { + // Remove landmark from category with null category parameter + ls.removeLandmarkFromCategory(lm, null); + assertTrue(false, "NullPointerException not thrown"); + } + catch (NullPointerException npe) + { + // Exception was thrown correctly + } + + // Silent failure if Landmark does not belong to category + ls.removeLandmarkFromCategory(lm, category2); + + // Silent failure if category does not exist + ls.removeLandmarkFromCategory(lm, "NonexistingCategory"); + + // Silent failure if category is empty string + ls.removeLandmarkFromCategory(lm, ""); + + // Silent failure if category name is too long + String tooLongCategory = new String(new char[MAX_CATEGORY_LENGTH + 1]); + ls.removeLandmarkFromCategory(lm, tooLongCategory); + + // Silent failure if Landmark does not belong to LandmarkStore + Landmark newLm = new Landmark("Not added", null, null, null); + ls.removeLandmarkFromCategory(newLm, category1); + + ls.deleteLandmark(lm); + ls.deleteCategory(category1); + ls.deleteCategory(category2); + } + + void testRemoveLandmarkFromCategory() throws Exception + { + setCurrentTest("testRemoveLandmarkFromCategory"); + + String category = "Category"; + String name = "lm"; + Landmark lm = new Landmark(name, null, null, null); + + ls = getDefaultLandmarkStore(); + ls.addCategory(category); + ls.addLandmark(lm, category); + + Enumeration e = ls.getLandmarks(category, name); + Landmark fetchedLm = findLandmark(e, name); + checkLandmark(fetchedLm, name, null, null, null); + + ls.removeLandmarkFromCategory(lm, category); + + Enumeration e2 = ls.getLandmarks(category, name); + assertTrue(e2 == null, "Landmark not removed from category"); + + // Delete the category and Landmark from the store + ls.deleteCategory(category); + ls.deleteLandmark(lm); + } + + void testRemoveLandmarkFromCategory2() throws Exception + { + setCurrentTest("testRemoveLandmarkFromCategory2()"); + + ls = getDefaultLandmarkStore(); + + // Add categories + String category1 = "category1"; + String category2 = "category2"; + ls.addCategory(category1); + ls.addCategory(category2); + + String name = "lm"; + Landmark lm = new Landmark(name, null, null, null); + + // Add landmark to category1 and category2 + ls.addLandmark(lm, category1); + ls.addLandmark(lm, category2); + + // Remove landmark from category1 + ls.removeLandmarkFromCategory(lm, category1); + + Enumeration e = ls.getLandmarks(category1, name); + assertTrue(e == null, "Landmark not removed from category"); + + // Make sure landmark still belongs to category2 + Enumeration e2 = ls.getLandmarks(category2, name); + Landmark fetchedLm = findLandmark(e2, name); + checkLandmark(fetchedLm, name, null, null, null); + + // Remove landmark from category2 + ls.removeLandmarkFromCategory(lm, category2); + + Enumeration e3 = ls.getLandmarks(category2, name); + assertTrue(e3 == null, "Landmark not removed from category"); + + // Delete the categories and Landmark from the store + ls.deleteCategory(category1); + ls.deleteCategory(category2); + ls.deleteLandmark(lm); + } + + void testGetLandmarksByNameBadArguments() throws Exception + { + setCurrentTest("testGetLandmarksByNameBadArguments()"); + + String maxName = new String(new char[MAX_NAME_LENGTH]); + + ls = getDefaultLandmarkStore(); + Landmark lm = new Landmark(maxName, null, null, null); + ls.addLandmark(lm, null); + + // Sanity check, find landmark by name + Enumeration e = ls.getLandmarks(null, maxName); + int count = findLandmarks(e, new String[] { maxName }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search with too long name + e = ls.getLandmarks(null, maxName + "x"); + assertTrue(e == null, "Expected getLandmarks to return null (1)"); + + // Search with empty string for name + e = ls.getLandmarks(null, ""); + assertTrue(e == null, "Expected getLandmarks to return null (2)"); + + ls.deleteLandmark(lm); + } + + void testGetLandmarksByName() throws Exception + { + setCurrentTest("testGetLandmarksByName()"); + + ls = getDefaultLandmarkStore(); + + addLandmarksAndCategoriesForSearch(); + + Enumeration e; + int count; + + // Search for landmark that does not exist + e = ls.getLandmarks(null, searchName0); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search for landmarks 1 + e = ls.getLandmarks(null, searchName1); + count = findLandmarks(e, new String[] { searchName1 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 2 + e = ls.getLandmarks(null, searchName2); + count = findLandmarks(e, new String[] { searchName2, searchName2 }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + // Search for landmarks 3 + e = ls.getLandmarks(null, searchName3); + count = findLandmarks(e, new String[] { searchName3, searchName3, + searchName3 + }); + assertTrue(count == 3, "Wrong number of landmarks found"); + + deleteAllLandmarksAndCategories(); + } + + void testGetLandmarksByNameUncategorized() throws Exception + { + setCurrentTest("testGetLandmarksByNameUncategorized()"); + + ls = getDefaultLandmarkStore(); + + addLandmarksAndCategoriesForSearch(); + + Enumeration e; + int count; + + // Find all landmarks that do not belong to a category + e = ls.getLandmarks("", null); + count = findLandmarks(e, new String[] { searchName1, searchName2 }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + // Search for landmarks 1 + e = ls.getLandmarks("", searchName1); + count = findLandmarks(e, new String[] { searchName1 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 3 + e = ls.getLandmarks("", searchName3); + assertTrue(e == null, "Expected getLandmarks to return null"); + + deleteAllLandmarksAndCategories(); + } + + void testGetLandmarksByNameWildcards() throws Exception + { + setCurrentTest("testGetLandmarksByNameWildcards()"); + + ls = getDefaultLandmarkStore(); + + String[] names = { "Hepa", "Huupa", "Lupa", "upo", "upa", "Lu?a", "*" }; + int length = names.length; + Landmark[] lms = new Landmark[length]; + + for (int i = 0; i < length; ++i) + { + lms[i] = new Landmark(names[i], null, null, null); + ls.addLandmark(lms[i], null); + } + + searchAndMatch("H*", new String[] { "Hepa", "Huupa" }); + searchAndMatch("*o", new String[] { "upo" }); + searchAndMatch("*upa", new String[] { "Huupa", "Lupa", "upa" }); + searchAndMatch("L*a", new String[] { "Lupa", "Lu?a" }); + searchAndMatch("*e*", new String[] { "Hepa" }); + + searchAndMatch("?", new String[] { "*" }); + searchAndMatch("up?", new String[] { "upa", "upo" }); + searchAndMatch("?upa", new String[] { "Lupa" }); + searchAndMatch("H?pa", new String[] { "Hepa" }); + searchAndMatch("?u??", new String[] { "Lupa", "Lu?a" }); + searchAndMatch("???", new String[] { "upo", "upa" }); + searchAndMatch("?????", new String[] { "Huupa" }); + + // Some complicated searches + searchAndMatch("*??pa", new String[] { "Hepa", "Huupa", "Lupa" }); + searchAndMatch("*u?a", new String[] { "Huupa", "Lupa", "upa", "Lu?a" }); + searchAndMatch("*up?", new String[] { "Huupa", "Lupa", "upo", "upa" }); + searchAndMatch("?*up?", new String[] { "Huupa", "Lupa" }); + searchAndMatch("*?*o*", new String[] { "upo" }); + + // Find all landmarks + searchAndMatch("*", names); + searchAndMatch("?*", names); + searchAndMatch("*?", names); + searchAndMatch("*?*", names); + + for (int i = 0; i < length; ++i) + { + ls.deleteLandmark(lms[i]); + } + } + + void testGetLandmarksByCategoryBadArguments() throws Exception + { + setCurrentTest("testGetLandmarksByCategoryBadArguments()"); + + ls = getDefaultLandmarkStore(); + + String maxCategoryName = new String(new char[MAX_CATEGORY_LENGTH]); + ls.addCategory(maxCategoryName); + + String name = "Wherever"; + Landmark lm = new Landmark(name, null, null, null); + ls.addLandmark(lm, maxCategoryName); + + // Sanity check, find landmark by category + Enumeration e = ls.getLandmarks(maxCategoryName, null); + int count = findLandmarks(e, new String[] { name }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search with too long category name + e = ls.getLandmarks(maxCategoryName + "x", null); + assertTrue(e == null, "Expected getLandmarks to return null (1)"); + + // Search with empty string for category name + e = ls.getLandmarks("", null); + assertTrue(e == null, "Expected getLandmarks to return null (2)"); + + ls.deleteLandmark(lm); + ls.deleteCategory(maxCategoryName); + } + + void testGetLandmarksByCategory() throws Exception + { + setCurrentTest("testGetLandmarksByCategory()"); + + ls = getDefaultLandmarkStore(); + + addLandmarksAndCategoriesForSearch(); + + Enumeration e; + int count; + + // Search for category that does not exist + e = ls.getLandmarks(searchCategory0, null); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search for landmarks 1 + e = ls.getLandmarks(searchCategory1, null); + count = findLandmarks(e, new String[] { searchName3 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 2 + e = ls.getLandmarks(searchCategory2, null); + count = findLandmarks(e, new String[] { searchName2, searchName3, + searchName3 + }); + assertTrue(count == 3, "Wrong number of landmarks found"); + + // Delete the categories and Landmarks from the store + deleteAllLandmarksAndCategories(); + } + + void testGetLandmarksByNameAndCategory() throws Exception + { + setCurrentTest("testGetLandmarksByNameAndCategory()"); + + ls = getDefaultLandmarkStore(); + + addLandmarksAndCategoriesForSearch(); + + Enumeration e; + int count; + + // Search with a category that does not exist + e = ls.getLandmarks(searchCategory0, searchName1); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search with a name that does not exist + e = ls.getLandmarks(searchCategory2, searchName0); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search with a name that does not exist in the category + e = ls.getLandmarks(searchCategory1, searchName1); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search for landmarks 1 + e = ls.getLandmarks(searchCategory1, searchName3); + count = findLandmarks(e, new String[] { searchName3 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 2 + e = ls.getLandmarks(searchCategory2, searchName3); + count = findLandmarks(e, new String[] { searchName3, searchName3 }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + // Search for landmarks 3 + e = ls.getLandmarks(searchCategory2, searchName2); + Landmark fetchedLm = findLandmark(e, searchName2); + checkLandmark(fetchedLm, searchName2, searchCategory2, null, null); + + // Delete the categories and Landmarks from the store + deleteAllLandmarksAndCategories(); + } + + void testGetLandmarksByAreaBadArguments() throws Exception + { + setCurrentTest("testGetLandmarksByAreaBadArguments()"); + ls = getDefaultLandmarkStore(); + + double minLat = -10.0d; + double maxLat = 10.0d; + double minLon = -110.0d; + double maxLon = 110.0d; + + // Bad minLat values + assertBadGetLandmarksByArea(-90.1d, maxLat, minLon, maxLon); + assertBadGetLandmarksByArea(90.1d, maxLat, minLon, maxLon); + + // Bad maxLat values + assertBadGetLandmarksByArea(minLat, -90.1d, minLon, maxLon); + assertBadGetLandmarksByArea(minLat, 90.1d, minLon, maxLon); + + // minLat > maxLat + assertBadGetLandmarksByArea(40.0d, 30.0d, minLon, maxLon); + + // Bad minLon values + assertBadGetLandmarksByArea(minLat, maxLat, -180.1d, maxLon); + assertBadGetLandmarksByArea(minLat, maxLat, 180.0d, maxLon); + + // Bad maxLon values + assertBadGetLandmarksByArea(minLat, maxLat, minLon, -180.1d); + assertBadGetLandmarksByArea(minLat, maxLat, minLon, 180.0d); + + try + { + Enumeration e = ls.getLandmarks(null, minLat, minLon, maxLat, + maxLon); + assertTrue(false, + "IllegalArgumentException not thrown for long category name"); + } + catch (IllegalArgumentException iae) + { + // Exception was thrown correctly + assertTrue(iae.getMessage() == null, + "Message not allowed for exception: " + iae); + } + + } + + void testGetLandmarksByArea() throws Exception + { + setCurrentTest("testGetLandmarksByArea()"); + + ls = getDefaultLandmarkStore(); + + addLandmarksAndCategoriesForSearch(); + + // -180 0 180 + // |---------|- 90 1 = searchName1 + // | | | 2 = searchName2 + // | 1 | | 3 = searchName3, searchCategory1 + // |----+----|- 0 4 = searchName3, searchCategory2 + // |2 |4 5| 5 = searchName3, searchCategory2 + // | 3 | | + // |---------|- -90 + + Enumeration e; + int count; + + // Search an area where there are no landmarks + e = ls.getLandmarks(null, 0.0d, 90.0d, 0.0d, 179.9d); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search for landmarks 1 + e = ls.getLandmarks(null, 0.0d, 90.0d, -180.0d, 0.0d); + count = findLandmarks(e, new String[] { searchName1 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 2 + e = ls.getLandmarks(null, -90.0d, 0.0d, -180.0d, 0.0d); + count = findLandmarks(e, new String[] { searchName2, searchName3 }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + // Search for landmarks 3 + e = ls.getLandmarks(null, -90.0d, 0.0d, 0.0d, 179.9d); + count = findLandmarks(e, new String[] { searchName3, searchName3 }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + // Search for landmarks - find lm2, smallest possible area + e = ls.getLandmarks(null, -5.0d, -5.0d, -180.0d, -180.0d); + count = findLandmarks(e, new String[] { searchName2 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks - search lon [-180, 0] and [100, 180) + e = ls.getLandmarks(null, -90.0d, 90.0d, 100.0d, 0.0d); + count = findLandmarks(e, new String[] { searchName1, searchName2, + searchName3, searchName3 + }); + assertTrue(count == 4, "Wrong number of landmarks found"); + + deleteAllLandmarksAndCategories(); + } + + void testGetLandmarksByArea2() throws Exception + { + setCurrentTest("testGetLandmarksByArea2()"); + + ls = getDefaultLandmarkStore(); + Landmark lm1 = new Landmark("Landmark1", "description", + new QualifiedCoordinates(10.0, 20.0, Float.NaN, Float.NaN, + Float.NaN), null); + ls.addLandmark(lm1, null); + ls.addLandmark(new Landmark("Landmark2", null, + new QualifiedCoordinates(40.0, 30.0, 0, 0, 0), null), null); + ls.addLandmark(new Landmark("Landmark3", null, + new QualifiedCoordinates(30.0, -10.0, 0, 0, 0), null), null); + ls.addLandmark(new Landmark("Landmark4", null, + new QualifiedCoordinates(30.0, 165.0, 0, 0, 0), null), null); + ls.addLandmark(new Landmark("Landmark5", null, + new QualifiedCoordinates(30.0, -165.0, 0, 0, 0), null), null); + + Enumeration e = ls.getLandmarks(null, -30.0, 50.0, 5.0, 25.0); + Landmark gotLandmark = findLandmark(e, "Landmark1"); + checkLandmark(gotLandmark, lm1.getName(), lm1.getDescription(), lm1 + .getQualifiedCoordinates(), lm1.getAddressInfo()); + assertTrue(!e.hasMoreElements(), "Wrong number of landmarks found"); + + deleteAllLandmarksAndCategories(); + } + + void testGetLandmarksByAreaAndCategory() throws Exception + { + setCurrentTest("testGetLandmarksByAreaAndCategory()"); + + ls = getDefaultLandmarkStore(); + + addLandmarksAndCategoriesForSearch(); + + // -180 0 180 + // |---------|- 90 1 = searchName1 + // | | | 2 = searchName2 + // | 1 | | 3 = searchName3, searchCategory1 + // |----+----|- 0 4 = searchName3, searchCategory2 + // |2 |4 5| 5 = searchName3, searchCategory2 + // | 3 | | + // |---------|- -90 + + Enumeration e; + int count; + + // Search a category that does not contain any landmarks + e = ls.getLandmarks(searchCategory0, -90.0d, 90.0d, -180.0d, 179.9d); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search an area that does not contain any landmarks in the category + e = ls.getLandmarks(searchCategory2, -90.0d, 90.0d, -180.0d, 0.0d); + assertTrue(e == null, "Expected getLandmarks to return null"); + + // Search for landmarks 1 + e = ls.getLandmarks(searchCategory1, -90.0d, 90.0d, -180.0d, 179.9d); + count = findLandmarks(e, new String[] { searchName3 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 2 + e = ls.getLandmarks(searchCategory2, -90.0d, 0.0d, -180.0d, 179.9d); + count = findLandmarks(e, new String[] { searchName3, searchName3 }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + // Search for landmarks 3 + e = ls.getLandmarks(searchCategory2, -90.0d, 0.0d, 100.0d, 179.9d); + count = findLandmarks(e, new String[] { searchName3 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + // Search for landmarks 4 - smallest possible search area + e = ls.getLandmarks(searchCategory1, -90.0d, -90.0d, -21.0d, -21.0d); + count = findLandmarks(e, new String[] { searchName3 }); + assertTrue(count == 1, "Wrong number of landmarks found"); + + deleteAllLandmarksAndCategories(); + } + + void testEnumerationDeleteLandmark1() throws Exception + { + setCurrentTest("testEnumerationDeleteLandmark1()"); + + ls = getDefaultLandmarkStore(); + + Landmark lm1 = new Landmark("lm1", null, null, null); + Landmark lm2 = new Landmark("lm2", null, null, null); + Landmark lm3 = new Landmark("lm3", null, null, null); + + ls.addLandmark(lm1, null); + ls.addLandmark(lm2, null); + ls.addLandmark(lm3, null); + + Enumeration e = ls.getLandmarks(); + assertTrue(e.hasMoreElements(), "Enumeration is empty"); + ls.deleteLandmark(lm1); + ls.deleteLandmark(lm2); + + // Expect lm1 because hasMoreElements should cache a Landmark + int count = findLandmarks(e, new String[] { "lm1", "lm3" }); + assertTrue(count == 2, "Wrong number of landmarks found"); + + ls.deleteLandmark(lm3); + } + + void testEnumerationDeleteLandmark2() throws Exception + { + setCurrentTest("testEnumerationDeleteLandmark2()"); + + ls = getDefaultLandmarkStore(); + + Landmark lm1 = new Landmark("lm1", null, null, null); + Landmark lm2 = new Landmark("lm2", null, null, null); + Landmark lm3 = new Landmark("lm3", null, null, null); + + ls.addLandmark(lm1, null); + ls.addLandmark(lm2, null); + ls.addLandmark(lm3, null); + + Enumeration e = ls.getLandmarks(); + ls.deleteLandmark(lm1); + ls.deleteLandmark(lm2); + ls.deleteLandmark(lm3); + + assertTrue(!e.hasMoreElements(), "Wrong number of landmarks found"); + } + + // ------------------------ Helper methods ----------------------- + + private void searchAndMatch(String aPattern, String[] aNames) + throws Exception + { + + Enumeration e = ls.getLandmarks(null, aPattern); + int count = findLandmarks(e, aNames); + assertTrue(count == aNames.length, "Wrong number of landmarks found"); + } + + // Add landmarks for testing getLandmarks + private void addLandmarksAndCategoriesForSearch() throws Exception + { + // -180 0 180 + // |---------|- 90 1 = searchName1 + // | | | 2 = searchName2 + // | 1 | | 3 = searchName3, searchCategory1 + // |----+----|- 0 4 = searchName3, searchCategory2 + // |2 |4 5| 5 = searchName3, searchCategory2 + // | 3 | | + // |---------|- -90 + + float alt = 0.0f; + float hacc = 100.0f; + float vacc = 100.0f; + + QualifiedCoordinates qc1 = new QualifiedCoordinates(27.0d, -17.0d, alt, + hacc, vacc); + QualifiedCoordinates qc2 = new QualifiedCoordinates(-5.0d, -180.0d, + alt, hacc, vacc); + QualifiedCoordinates qc3 = new QualifiedCoordinates(-90.0d, -21.0d, + alt, hacc, vacc); + QualifiedCoordinates qc4 = new QualifiedCoordinates(-5.0d, 5.0d, alt, + hacc, vacc); + QualifiedCoordinates qc5 = new QualifiedCoordinates(-5.0d, 179.0d, alt, + hacc, vacc); + + // | Category | Landmarks + // |-----------------|-------------------------------------- + // | null | searchName1, searchName2 + // | searchCategory1 | searchName3 + // | searchCategory2 | searchName2, searchName3, searchName3 + + // Add categories + ls.addCategory(searchCategory1); + ls.addCategory(searchCategory2); + + // Add landmarks to default category + Landmark lm1 = new Landmark(searchName1, null, qc1, null); + Landmark lm2 = new Landmark(searchName2, null, qc2, null); + ls.addLandmark(lm1, null); + ls.addLandmark(lm2, null); + + // Add landmarks to searchCategory1 (description = category) + Landmark lm3 = new Landmark(searchName3, searchCategory1, qc3, null); + ls.addLandmark(lm3, searchCategory1); + + // Add landmark to searchCategory2 (description = category) + Landmark lm4 = new Landmark(searchName3, searchCategory2, qc4, null); + Landmark lm5 = new Landmark(searchName3, searchCategory2, qc5, null); + Landmark lm6 = new Landmark(searchName2, searchCategory2, null, null); + ls.addLandmark(lm4, searchCategory2); + ls.addLandmark(lm5, searchCategory2); + ls.addLandmark(lm6, searchCategory2); + } + + private LandmarkStore getDefaultLandmarkStore() + { + LandmarkStore store = LandmarkStore.getInstance(null); + assertTrue(store != null, "LandmarkStore is null"); + return store; + } + + private void assertEmptyLandmarkStore() throws Exception + { + setCurrentTest("assertEmptyLandmarkStore"); + ls = getDefaultLandmarkStore(); + Enumeration le = ls.getLandmarks(); + assertTrue(le == null, "Landmarks exist in LandmarkStore"); + + Enumeration ce = ls.getCategories(); + assertTrue(!ce.hasMoreElements(), "Categories exist in LandmarkStore"); + } + + private void saveRetrieveDelete(Landmark aLm) throws Exception + { + String name = aLm.getName(); + String description = aLm.getDescription(); + QualifiedCoordinates coords = aLm.getQualifiedCoordinates(); + AddressInfo address = aLm.getAddressInfo(); + + // Get the LandmarkStore + ls = LandmarkStore.getInstance(null); + assertTrue(ls != null, "LandmarkStore is null"); + + // Save the landmark + ls.addLandmark(aLm, iCategory); + + // Get all landmarks and search for the one we added + Enumeration e = ls.getLandmarks(); + Landmark fetchedLm = findLandmark(e, name); + + ls.deleteLandmark(aLm); + assertTrue(e != null, "No landmarks found in database"); + checkLandmark(fetchedLm, name, description, coords, address); + + ls.deleteLandmark(aLm); // Try to delete again, should be silently + // ignored + } + + private Landmark findLandmark(Enumeration e, String aName) + { + Landmark foundLm = null; + + if (e != null) + { + // Search for the saved one + while (e.hasMoreElements()) + { + Landmark aLandmark = (Landmark) e.nextElement(); + assertTrue(aLandmark != null, "Enumeration contains a null"); + + if (aName.equals(aLandmark.getName())) + { + assertTrue(foundLm == null, + "More that one landmark called " + aName); + foundLm = aLandmark; + break; + } + } + } + + return foundLm; + } + + // Returns number of Landmarks in the enumeration + // Also checks that Landmarks with correct names are found + private int findLandmarks(Enumeration e, String[] aNames) + { + int length = aNames != null ? aNames.length : 0; + + boolean[] found = new boolean[length]; + int numLandmarks = 0; + + if (e != null) + { + // Search for the saved one + while (e.hasMoreElements()) + { + Landmark aLandmark = (Landmark) e.nextElement(); + assertTrue(aLandmark != null, "Enumeration contains a null"); + ++numLandmarks; + + for (int i = 0; i < length; ++i) + { + if (aNames[i].equals(aLandmark.getName())) + { + found[i] = true; + } + } + } + } + + for (int i = 0; i < length; ++i) + { + assertTrue(found[i], "Landmark '" + aNames[i] + "' not found"); + } + + return numLandmarks; + } + + private void findCategory(Enumeration e, String aCategory) + { + assertTrue(e != null, "Categories enumeration is null"); + assertTrue(e.hasMoreElements(), "Categories enumeration is empty"); + + // Check that both category is present + boolean found = false; + while (e.hasMoreElements()) + { + String s = (String) e.nextElement(); + if (aCategory.equals(s)) + { + found = true; + } + } + + assertTrue(found, "Category " + aCategory + " not found"); + } + + private void assertEqual(String errorMsg, String dis, String dat) + { + if (dis == null) + { + assertTrue(dat == null, errorMsg + ": " + dat + " != null"); + } + else + { + assertTrue(dis.equals(dat), errorMsg + ": " + dis + " != " + dat); + } + } + + private void assertBadGetLandmarksByArea(double aMinLat, double aMaxLat, + double aMinLon, double aMaxLon) throws Exception + { + try + { + Enumeration e = ls.getLandmarks(null, aMinLat, aMinLon, aMaxLat, + aMaxLon); + String args = "getLandmarks(null, " + aMinLat + ", " + aMaxLat + + ", " + aMinLon + ", " + aMaxLon + ")"; + + assertTrue(false, "IllegalArgumentException not thrown for " + args); + } + catch (IllegalArgumentException iae) + { + // Exception was thrown correctly + assertTrue(iae.getMessage() == null, + "Message not allowed for exception: " + iae); + } + } + + private void checkLandmark(Landmark aLm, String aName, String aDescription, + QualifiedCoordinates aCoords, AddressInfo aAddress) + { + + assertTrue(aLm != null, "Landmark is null"); + + // echo("name = " + aLm.getName() + ", desc = " + aLm.getDescription()); + + // Check the values + String incorrect = "Wrong value retrieved from LandmarkStore: "; + assertEqual(incorrect + "name", aName, aLm.getName()); + assertEqual(incorrect + "description", aDescription, aLm + .getDescription()); + + checkCoordinates(aCoords, aLm.getQualifiedCoordinates()); + checkAddressInfo(aAddress, aLm.getAddressInfo()); + } + + private void checkCoordinates(QualifiedCoordinates aCorrectCoords, + QualifiedCoordinates aThatCoords) + { + if (aCorrectCoords == null) + { + assertTrue(aThatCoords == null, "Coordinates should have been null"); + return; + } + + assertTrue(aThatCoords != null, + "Coordinate null when retrieved from LandmarkStore"); + + // echo("lat = " + aThatCoords.getLatitude() + + // ", lon = " + aThatCoords.getLongitude() + + // ", alt = " + aThatCoords.getAltitude() + + // ", hacc = " + aThatCoords.getHorizontalAccuracy() + + // ", vacc = " + aThatCoords.getVerticalAccuracy()); + + assertTrue(aThatCoords.getLatitude() == aCorrectCoords.getLatitude(), + "Latitude incorrect when retrieved from LandmarkStore"); + assertTrue(aThatCoords.getLongitude() == aCorrectCoords.getLongitude(), + "Longitude incorrect when retrieved from LandmarkStore"); + assertTrue(isSameFloat(aThatCoords.getAltitude(), aCorrectCoords + .getAltitude()), + "Altitude incorrect when retrieved from LandmarkStore"); + assertTrue(isSameFloat(aThatCoords.getHorizontalAccuracy(), + aCorrectCoords.getHorizontalAccuracy()), + "HorizontalAccuracy incorrect when retrieved from LandmarkStore"); + assertTrue(isSameFloat(aThatCoords.getVerticalAccuracy(), + aCorrectCoords.getVerticalAccuracy()), + "VerticalAccuracy incorrect when retrieved from LandmarkStore"); + } + + private void checkAddressInfo(AddressInfo aCorrectAddress, + AddressInfo aThatAddress) + { + if (aCorrectAddress == null) + { + assertTrue(aThatAddress == null, + "AddressInfo should have been null"); + return; + } + + assertTrue(aThatAddress != null, + "AddressInfo null when retrieved from LandmarkStore"); + + // Check that address strings are the same as the input ones + for (int i = 1; i <= 17; ++i) + { + String original = aCorrectAddress.getField(i); + String stored = aThatAddress.getField(i); + if (original != null) + { + assertTrue(original.equals(stored), "AddressInfo incorrect (" + + i + "): " + original + " != " + stored); + } + else + { + assertTrue(stored == null, "AddressInfo incorrect: (" + i + + "): " + stored + " != null"); + } + } + } + + private boolean isSameFloat(float aF1, float aF2) + { + if (new Float(aF1).equals(new Float(aF2))) + { + return true; + } + echo("Floats are different: " + aF1 + " != " + aF2); + echo("IntBits1 = " + Float.floatToIntBits(aF1)); + echo("IntBits2 = " + Float.floatToIntBits(aF2)); + return false; + } + +}